📄 hamaro_reg.c
字号:
static char *rvm_msg = "RegisterVerifyRegFilter()";
if ((hamaro_demod_register_map[idx].regfilter&(HAMARO_REGF_COBRA|HAMARO_REGF_CAM_DEF|HAMARO_REGF_CAM_EXT|HAMARO_REGF_COBRA|HAMARO_REGF_CAM_RED|HAMARO_REGF_ZEROB6)) == 0)
{
/* invalid setting in reg.map, report to app */
HAMARO_DRIVER_SET_ERROR_MSG(nim,HAMARO_REG_VERFY_IDX,rvm_msg,idx);
return(False);
}
return(True);
} /* RegisterVerifyRegFilter() */
/*******************************************************************************************************/
/* RegisterVerifyRegDataType() */
/*******************************************************************************************************/
static BOOL RegisterVerifyRegDataType( /* function to verify register data type value in reg.map */
HAMARO_NIM *nim, /* pointer to nim */
int idx) /* register to test */
{
static char *rvm_msg = "RegisterVerifyRegDataType()";
/* test data-type contained in reg.map against 1) valid type; 2) bit_count must be consistant */
switch (hamaro_demod_register_map[idx].reg_type)
{
case HAMARO_REGT_INT:
case HAMARO_REGT_UINT:
case HAMARO_REGT_LONG:
case HAMARO_REGT_ULONG:
case HAMARO_REGT_EOLIST:
{
/* above constitute valid values in reg.map */
break;
}
case HAMARO_REGT_MINT:
{
/* length must be > 8 */
if (hamaro_demod_register_map[idx].bit_count < 9)
{
HAMARO_DRIVER_SET_ERROR_MSG(nim,HAMARO_REG_VERFY_IDX,rvm_msg,idx);
return(False);
}
break;
}
case HAMARO_REGT_BYTE:
{
/* length must be <= 8 */
if (hamaro_demod_register_map[idx].bit_count > 8)
{
HAMARO_DRIVER_SET_ERROR_MSG(nim,HAMARO_REG_VERFY_IDX,rvm_msg,idx);
return(False);
}
break;
}
case HAMARO_REGT_BITHL:
case HAMARO_REGT_BIT:
{
/* length must be == 1 */
if (hamaro_demod_register_map[idx].bit_count != 1)
{
HAMARO_DRIVER_SET_ERROR_MSG(nim,HAMARO_REG_VERFY_IDX,rvm_msg,idx);
return(False);
}
break;
}
case HAMARO_REGT_NULL:
{
/* perform no special tests on register designated as NULL */
break;
}
default:
{
/* invalid setting in reg.map, report to app */
HAMARO_DRIVER_SET_ERROR_MSG(nim,HAMARO_REG_VERFY_IDX,rvm_msg,idx);
return(False);
}
} /* switch(... */
return(True);
} /* RegisterVerifyRegDataType() */
/*******************************************************************************************************/
/* RegisterVerifyRegDefault() */
/*******************************************************************************************************/
static BOOL RegisterVerifyRegDefault( /* function to verify range of default setting in reg.map */
HAMARO_NIM *nim, /* pointer to nim */
int idx) /* register to test */
{
static char *rvm_msg = "RegisterVerifyRegDefault()";
unsigned long ulTemp;
/* create max bit pattern to test against */
ulTemp = (hamaro_demod_register_map[idx].bit_count == 0 ? 0x01UL : (0x01UL<<hamaro_demod_register_map[idx].bit_count));
/* bitmap in l will be pow(2,bit_count)+1, so values below this are valid */
if (hamaro_demod_register_map[idx].default_value >= ulTemp && hamaro_demod_register_map[idx].default_value != 0xffffffffUL)
{
if (hamaro_demod_register_map[idx].reg_type != HAMARO_REGT_NULL)
{
/* invalid setting in reg.map, report to app */
HAMARO_DRIVER_SET_ERROR_MSG(nim,HAMARO_REG_VERFY_IDX,rvm_msg,idx);
return(False);
}
} /* switch(... */
return(True);
} /* RegisterVerifyRegDefault() */
/*******************************************************************************************************/
/* RegisterVerifyRegBitCount() */
/*******************************************************************************************************/
static BOOL RegisterVerifyRegBitCount( /* function to verify that bit count rules are adhered to */
HAMARO_NIM *nim, /* pointer to nim */
int idx) /* register to test */
{
static char *rvm_msg = "RegisterVerifyRegBitCount()";
int len;
/* bit count of zero is an error! */
if (hamaro_demod_register_map[idx].bit_count != 0)
{
/* test for bit counts of less-eq 8 */
if (hamaro_demod_register_map[idx].bit_count <= 8)
{
/* calc the number of valid positions starting pt. can be */
len = (8 - hamaro_demod_register_map[idx].bit_count);
if (RegisterOneOf((signed char)(hamaro_demod_register_map[idx].start_bit+'0'),"76543210",len+1) == True) return(True);
}
else
{
/* if bit-count > 8, then start can be anywhere --> look at reg.map SYSSymbolRate[21:0] */
return(True);
}
}
/* invalid setting in reg.map, report to app */
HAMARO_DRIVER_SET_ERROR_MSG(nim,HAMARO_REG_VERFY_IDX,rvm_msg,idx);
return(False);
} /* RegisterVerifyBitCount() */
/*******************************************************************************************************/
/* RegisterOneOf() */
/*******************************************************************************************************/
BOOL RegisterOneOf( /* function to find match in match_list for len. */
char match, /* char to match */
char *match_list, /* list to match against */
int len) /* max length of match_list */
{
register int i;
/* try to match 'match' with 'match_list[0..n] */
for (i = 0 ; match_list[i] != CNULL ; i++)
{
if (match == match_list[i]) return(True);
if (i > 255) break;
if (i >= len) break;
}
return(False);
} /* RegisterOneOf() */
#endif /* HAMARO_INCLUDE_DEBUG */
/*******************************************************************************************************/
/* HAMARO_Register_bitlength() */
/*******************************************************************************************************/
int HAMARO_Register_bitlength( /* returns the length in bit of a register */
HAMARO_REGIDX regidx) /* regidx of register number to read bitlength of */
{
return(hamaro_demod_register_map[regidx].bit_count);
} /* HAMARO_Register_bitlength() */
/*******************************************************************************************************/
/* HAMARO_RegisterWritePLLMult() */
/*******************************************************************************************************/
BOOL HAMARO_RegisterWritePLLMult( /* function to write PLLMult register */
HAMARO_NIM *nim, /* pointer to nim */
unsigned long ulRegVal) /* value to write to PLLMult register */
{
/* only write the PLLMult value if it is different from the last value
* programmed to the PLLMult register.
*/
if (nim->ucPLLMult_shadow != (unsigned char)ulRegVal)
{
if (HAMARO_RegisterWrite(nim,CX2430X_PLLMULT,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)
{
return (False);
}
nim->ucPLLMult_shadow = (unsigned char)ulRegVal;
}
return (True);
} /* HAMARO_RegisterWritePLLMult() */
/*******************************************************************************************************/
/* HAMARO_RegisterReadCentralFreq() */
/*******************************************************************************************************/
BOOL HAMARO_RegisterReadCentralFreq( /* function to read current central freq register for camaric */
HAMARO_NIM *nim, /* pointer to nim */
unsigned long *pFreq) /* pointer to returned frequency value */
{
unsigned long ulRegVal = 0UL;
/* initialize return value */
*pFreq = 0UL;
/* read the sign bit and shift it to bit 12 */
if (HAMARO_RegisterRead(nim,CX2430X_ACQPRFREQCURRSIGN,&ulRegVal, HAMARO_DEMOD_I2C_IO) != True)
{
return(False);
}
*pFreq |= ulRegVal << 12;
/* read the MSB of mantissa and shift it to bit 11 */
if (HAMARO_RegisterRead(nim,CX2430X_ACQPRFREQCURRMSB,&ulRegVal, HAMARO_DEMOD_I2C_IO) != True)
{
return(False);
}
*pFreq |= ulRegVal << 4;
/* read the LSB of mantissa */
if (HAMARO_RegisterRead(nim,CX2430X_ACQPRFREQCURRLSB,&ulRegVal, HAMARO_DEMOD_I2C_IO) != True)
{
return(False);
}
*pFreq |= ulRegVal;
return (True);
} /* HAMARO_RegisterReadCentralFreq() */
/*******************************************************************************************************/
/* HAMARO_RegisterWriteCentralFreq() */
/*******************************************************************************************************/
BOOL HAMARO_RegisterWriteCentralFreq( /* function to write nominal central freq register for camaric */
HAMARO_NIM *nim, /* pointer to nim */
unsigned long ulFreq) /* frequency value to write */
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -