📄 ver8f0.c
字号:
/* INPUT : register id */
/* RETURN : data */
/*****************************************************************************/
S32 RegGetOneRegister(S32 reg_id)
{
U8 ChipAddress;
S32 nbdata,error;
ChipAddress=0x38;
/*I2C access*/
I2cReadWrite(WRITE,ChipAddress,&RegMap[reg_id].Addr,1);
/*printf("\nadd%x",RegMap[reg_id].Addr);*/
/* getch();*/
I2cReadWrite(READ,ChipAddress,&RegMap[reg_id].Value,1);
/*printf("\nval%x",RegMap[reg_id].Value);*/
/* getch();*/
RegNbI2cAccess += 1;
return(RegMap[reg_id].Value) ;
}
/******** RegReset ***********************************************************/
/* Set Chip register values according Default Values stored in ValRegReset */
/* */
/*****************************************************************************/
void RegReset(void)
{
S32 reg ;
for ( reg = 0 ; reg < NBREG ; reg++ )
{
RegSetOneRegister(reg,RegMap[reg].Reset);
/*getch();*/
}
}
void Reg_All_Write(void)
{
S32 reg ;
for ( reg = 0 ; reg < NBREG ; reg++ )
{
RegSetOneRegister(reg,RegMap[reg].Value);
/*getch();*/
}
}
/******** RegStoreValue ******************************************************/
/* Store the current chip register values */
/* */
/*****************************************************************************/
void RegStoreValue(void)
{
S32 reg ;
/* */
for ( reg = 0 ; reg < NBREG ; reg++ )
RegMap[reg].Store = RegMap[reg].Value ;
return;
/* */
}
/* */
/******** RegReloadValue ******************************************************/
/* Reload the chip register stored values */
/* */
/*****************************************************************************/
void RegReloadValue(void)
{
S32 reg ;
/* */
for ( reg = 0 ; reg < NBREG ; reg++ )
{
RegMap[reg].Value = RegMap[reg].Store ;
RegSetOneRegister(reg,RegMap[reg].Value);
}
/* */
return;
/* */
}
/* */
/******** 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(S32 field, S32 fieldval)
{
S32 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*/
}
/******** RegSetField ***********************************************************/
/* Set Chip register bits of the field "field" to the value "value" */
/* Input : index of the field and value to write */
/********************************************************************************/
void ROUTINE RegSetField(S32 field,S32 value)
{
S32 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*/
}
/******** FieldGetVal ***************************************************************/
/* Compute the value of the field with the register value store in REGMAP */
/* Input : index of the field */
/* Output: value of the field */
/************************************************************************************/
S32 FieldGetVal(S32 field)
{
S32 value;
FIELD *pfield;
pfield=&(FieldMap[field]);
value= RegMap[pfield->Reg].Value;
#if 1 /*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*/
#endif
return value;
}
/******** RegGetField ***************************************************************/
/* Get Chip register Value (bitwise) then store Value in structure REGMAP */
/* Input : index of the field */
/* Output: value of the field */
/************************************************************************************/
S32 ROUTINE RegGetField(S32 field)
{
S32 mask = 0,
val=0;
FIELD *pfield;
pfield=&(FieldMap[field]); /*Just for code simplification*/
/* I2C Read : register address set-up */
RegGetOneRegister(pfield->Reg); /*Read the register*/
#if 0
printf("field value %d",field);
/*getch();*/
#endif
return FieldGetVal(field);
}
/******** FieldSearchName ***********************/
/* Function : search the index of the */
/* field which name is _VariableName */
/* input parameter : _VariableName */
/* output parameter : Index */
/************************************************/
S32 ROUTINE FieldSearchName(S8 * _VariableName)
{
S32 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 */
/************************************************/
S32 ROUTINE RegSearchName(S8 * _VariableName)
{
S32 Index=-1;
for(Index = 0; ((Index < NBREG)&&(strcmp(RegMap[Index].Name,_VariableName)!= 0)); Index++) ;
if(Index>= NBREG)
Index = -1 ;
return (Index);
}
/********** RegSearchAddress ********************/
/* Function : search the index of the */
/* register which address is _Address */
/* input parameter : _Address */
/* output parameter : Index */
/************************************************/
S32 ROUTINE RegSearchAddress(S32 _Address)
{
S32 Index=-1;
for(Index = 0; ((Index < NBREG)&&(RegMap[Index].Addr !=_Address)); Index++) ;
if(Index>= NBREG)
Index = -1 ;
return (Index);
}
void ROUTINE QAM64_RegInit(void)
{
S16 i;
S32 S32val;
S32val = Driv0297Signal.QAMSize;
/*捞巴篮 stv0297 file阑 持篮 巴捞促.*/
/*
REGISTER INITIALISATION
-----------------------
*/
/* EQU_0*/
RegMap[EQU_0].Addr = 0x00 ;
RegMap[EQU_0].Reset = 0x48 ;
if(S32val == 16)
RegMap[EQU_0].Reset = 0x08 ;
if(S32val == 32)
RegMap[EQU_0].Reset = 0x18 ;
if(S32val == 64)
RegMap[EQU_0].Value = 0x48 ; /* orginal 09*/
if(S32val == 128)
RegMap[EQU_0].Value = 0x28 ; /* orginal 09*/
if(S32val == 256)
RegMap[EQU_0].Value = 0x38 ; /* orginal 09*/
strcpy(RegMap[EQU_0].Name,"EQU_0") ;
/* FIELDS*/
strcpy(FieldMap[U_THRESHOLD].Name,"U_THRESHOLD") ;
FieldMap[U_THRESHOLD].Reg = EQU_0 ;
FieldMap[U_THRESHOLD].Pos = 0 ;
FieldMap[U_THRESHOLD].Bits = 4 ;
FieldMap[U_THRESHOLD].Type = UNSIGNED ;
FieldMap[U_THRESHOLD].Mask = FieldCreateMask(U_THRESHOLD) ;
strcpy(FieldMap[MODE_SELECT].Name,"MODE_SELECT") ;
FieldMap[MODE_SELECT].Reg = EQU_0 ;
FieldMap[MODE_SELECT].Pos = 4 ;
FieldMap[MODE_SELECT].Bits = 3 ;
FieldMap[MODE_SELECT].Type = UNSIGNED ;
FieldMap[MODE_SELECT].Mask = FieldCreateMask(MODE_SELECT) ;
/* EQU_1*/
RegMap[EQU_1].Addr = 0x01 ;
RegMap[EQU_1].Reset = 0x58 ;
RegMap[EQU_1].Value = 0x69 ;
strcpy(RegMap[EQU_1].Name,"EQU_1") ;
/* FIELDS*/
strcpy(FieldMap[BLIND_U].Name,"BLIND_U") ;
FieldMap[BLIND_U].Reg = EQU_1 ;
FieldMap[BLIND_U].Pos = 0 ;
FieldMap[BLIND_U].Bits = 4 ;
FieldMap[BLIND_U].Type = UNSIGNED ;
FieldMap[BLIND_U].Mask = FieldCreateMask(BLIND_U) ;
strcpy(FieldMap[INITIAL_U].Name,"INITIAL_U") ;
FieldMap[INITIAL_U].Reg = EQU_1 ;
FieldMap[INITIAL_U].Pos = 4 ;
FieldMap[INITIAL_U].Bits = 4 ;
FieldMap[INITIAL_U].Type = UNSIGNED ;
FieldMap[INITIAL_U].Mask = FieldCreateMask(INITIAL_U) ;
/* EQU_2*/
RegMap[TST_EQU_2].Addr = 0x02 ;
RegMap[TST_EQU_2].Reset = 0x00 ;
RegMap[TST_EQU_2].Value = 0x00 ;
strcpy(RegMap[TST_EQU_2].Name,"TEST:EQU_2") ;
#if 0
/* EQU_5*/
RegMap[TST_EQU_5].Addr = 0x05 ;
RegMap[TST_EQU_5].Reset = 0x00 ;
RegMap[TST_EQU_5].Value = 0x00 ;
strcpy(RegMap[TST_EQU_5].Name,"TEST:EQU_5") ;
/* EQU_6*/
RegMap[TST_EQU_6].Addr = 0x06 ;
RegMap[TST_EQU_6].Reset = 0x00 ;
RegMap[TST_EQU_6].Value = 0x00 ;
strcpy(RegMap[TST_EQU_6].Name,"TEST:EQU_6") ;
#endif
/* EQU_3*/
RegMap[EQU_3].Addr = 0x03 ;
RegMap[EQU_3].Reset = 0x00 ;
RegMap[EQU_3].Value = 0x00 ;
strcpy(RegMap[EQU_3].Name,"EQU_3") ;
/* FIELDS*/
strcpy(FieldMap[EQ_FSM_CTL].Name,"EQ_FSM_CTL") ;
FieldMap[EQ_FSM_CTL].Reg = EQU_3 ;
FieldMap[EQ_FSM_CTL].Pos = 0 ;
FieldMap[EQ_FSM_CTL].Bits = 2 ;
FieldMap[EQ_FSM_CTL].Type = UNSIGNED ;
FieldMap[EQ_FSM_CTL].Mask = FieldCreateMask(EQ_FSM_CTL) ;
/* FIELDS*/
strcpy(FieldMap[EQ_COEFF_CTL].Name,"EQ_COEFF_CTL") ;
FieldMap[EQ_COEFF_CTL].Reg = EQU_3 ;
FieldMap[EQ_COEFF_CTL].Pos = 2 ;
FieldMap[EQ_COEFF_CTL].Bits = 2 ;
FieldMap[EQ_COEFF_CTL].Type = UNSIGNED ;
FieldMap[EQ_COEFF_CTL].Mask = FieldCreateMask(EQ_COEFF_CTL) ;
/* EQU_4*/
RegMap[EQU_4].Addr = 0x04 ;
RegMap[EQU_4].Reset = 0x00 ;
RegMap[EQU_4].Value = 0x00 ;
strcpy(RegMap[EQU_4].Name,"EQU_4") ;
/* FIELDS*/
strcpy(FieldMap[NBLIND].Name,"NBLIND") ;
FieldMap[NBLIND].Reg = EQU_4 ;
FieldMap[NBLIND].Pos = 0 ;
FieldMap[NBLIND].Bits = 1 ;
FieldMap[NBLIND].Type = UNSIGNED ;
FieldMap[NBLIND].Mask = FieldCreateMask(NBLIND) ;
/* EQU_7*/
RegMap[EQU_7].Addr = 0x07 ;
RegMap[EQU_7].Reset = 0x00 ;
RegMap[EQU_7].Value = 0x00 ;
strcpy(RegMap[EQU_7].Name,"EQU_7") ;
/* FIELDS*/
strcpy(FieldMap[NOISE_EST_LO].Name,"NOISE_EST_LO") ;
FieldMap[NOISE_EST_LO].Reg = EQU_7 ;
FieldMap[NOISE_EST_LO].Pos = 0 ;
FieldMap[NOISE_EST_LO].Bits = 8 ;
FieldMap[NOISE_EST_LO].Type = UNSIGNED ;
FieldMap[NOISE_EST_LO].Mask = FieldCreateMask(NOISE_EST_LO) ;
/* EQU_8*/
RegMap[EQU_8].Addr = 0x08 ;
RegMap[EQU_8].Reset = 0x00 ;
RegMap[EQU_8].Value = 0x00 ;
strcpy(RegMap[EQU_8].Name,"EQU_8") ;
/* FIELDS*/
strcpy(FieldMap[NOISE_EST_HI].Name,"NOISE_EST_HI") ;
FieldMap[NOISE_EST_HI].Reg = EQU_8 ;
FieldMap[NOISE_EST_HI].Pos = 0 ;
FieldMap[NOISE_EST_HI].Bits = 8 ;
FieldMap[NOISE_EST_HI].Type = UNSIGNED ;
FieldMap[NOISE_EST_HI].Mask = FieldCreateMask(NOISE_EST_HI) ;
/* INITDEM_0*/
RegMap[INITDEM_0].Addr = 0x20 ;
RegMap[INITDEM_0].Reset = 0x00 ;
RegMap[INITDEM_0].Value = 0x00 ;
strcpy(RegMap[INITDEM_0].Name,"INITDEM_0") ;
/* FIELDS*/
strcpy(FieldMap[DEM_FQCY_LO].Name,"DEM_FQCY_LO") ;
FieldMap[DEM_FQCY_LO].Reg = INITDEM_0 ;
FieldMap[DEM_FQCY_LO].Pos = 0 ;
FieldMap[DEM_FQCY_LO].Bits = 8 ;
FieldMap[DEM_FQCY_LO].Type = UNSIGNED ;
FieldMap[DEM_FQCY_LO].Mask = FieldCreateMask(DEM_FQCY_LO) ;
/* INITDEM_1*/
RegMap[INITDEM_1].Addr = 0x21 ;
RegMap[INITDEM_1].Reset = 0x40 ;
RegMap[INITDEM_1].Value = 0x00 ;
strcpy(RegMap[INITDEM_1].Name,"INITDEM_1") ;
/* FIELDS*/
strcpy(FieldMap[DEM_FQCY_HI].Name,"DEM_FQCY_HI") ;
FieldMap[DEM_FQCY_HI].Reg = INITDEM_1 ;
FieldMap[DEM_FQCY_HI].Pos = 0 ;
FieldMap[DEM_FQCY_HI].Bits = 8 ;
FieldMap[DEM_FQCY_HI].Type = UNSIGNED ;
FieldMap[DEM_FQCY_HI].Mask = FieldCreateMask(DEM_FQCY_HI) ;
FieldMap[DEM_FQCY_LO].Mask = FieldCreateMask(DEM_FQCY_LO) ;
/* INITDEM_2*/
RegMap[INITDEM_2].Addr = 0x22 ;
RegMap[INITDEM_2].Reset = 0x00 ;
RegMap[INITDEM_2].Value = 0x00 ;
strcpy(RegMap[INITDEM_2].Name,"INITDEM_2") ;
/* FIELDS*/
strcpy(FieldMap[LATENCY].Name,"LATENCY") ;
FieldMap[LATENCY].Reg = INITDEM_2 ;
FieldMap[LATENCY].Pos = 0 ;
FieldMap[LATENCY].Bits = 8 ;
FieldMap[LATENCY].Type = UNSIGNED ;
FieldMap[LATENCY].Mask = FieldCreateMask(LATENCY) ;
/* INITDEM_3*/
RegMap[INITDEM_3].Addr = 0x23 ;
RegMap[INITDEM_3].Reset = 0x00 ;
RegMap[INITDEM_3].Value = 0x00 ;
strcpy(RegMap[INITDEM_3].Name,"INITDEM_3") ;
/* FIELDS*/
strcpy(FieldMap[SCAN_STEP_LO].Name,"SCAN_STEP_LO") ;
FieldMap[SCAN_STEP_LO].Reg = INITDEM_3 ;
FieldMap[SCAN_STEP_LO].Pos = 0 ;
FieldMap[SCAN_STEP_LO].Bits = 8 ;
FieldMap[SCAN_STEP_LO].Type = UNSIGNED ;
FieldMap[SCAN_STEP_LO].Mask = FieldCreateMask(SCAN_STEP_LO) ;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -