/**
@brief Get system register byte.
*/
int
tua9001_GetSysRegByte(
TUNER_MODULE *pTuner,
unsigned short RegAddr,
unsigned char *pReadingByte
)
{
// Get demod system register byte.
// if(RTK_SYS_Byte_Read(RegAddr, LEN_1_BYTE, pReadingByte) != TRUE)
// goto error_status_get_system_registers;
I2C_BRIDGE_MODULE *pI2cBridge;
BASE_INTERFACE_MODULE *pBaseInterface;
struct dvb_usb_device *d;
// Get I2C bridge.
pI2cBridge = pTuner->pI2cBridge;
pBaseInterface = pTuner->pBaseInterface;
pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
if ( read_usb_sys_char_bytes(d, RTD2832U_SYS, RegAddr, pReadingByte, LEN_1_BYTE) )
goto error_status_get_system_registers;
return FUNCTION_SUCCESS;
error_status_get_system_registers:
return FUNCTION_ERROR;
}
/**
@brief Get tuner RSSI value when calibration is on.
One can use rtl2832_fc0013_GetTunerRssiCalOn() to get tuner calibration-on RSSI value.
@param [in] pNim The NIM module pointer
@retval FUNCTION_SUCCESS Get tuner calibration-on RSSI value successfully.
@retval FUNCTION_ERROR Get tuner calibration-on RSSI value unsuccessfully.
*/
int
rtl2832_fc0013_GetTunerRssiCalOn(
DVBT_NIM_MODULE *pNim
)
{
TUNER_MODULE *pTuner;
DVBT_DEMOD_MODULE *pDemod;
FC0013_EXTRA_MODULE *pTunerExtra;
RTL2832_FC0013_EXTRA_MODULE *pNimExtra;
BASE_INTERFACE_MODULE *pBaseInterface;
// Get tuner module and demod module.
pTuner = pNim->pTuner;
pDemod = pNim->pDemod;
// Get tuner extra module.
pTunerExtra = &(pTuner->Extra.Fc0013);
// Get NIM extra module.
pNimExtra = &(pNim->Extra.Rtl2832Fc0013);
// Get NIM base interface.
pBaseInterface = pNim->pBaseInterface;
// Set tuner EN_CAL_RSSI to 0x1.
if(fc0013_SetRegMaskBits(pTuner, 0x9, 4, 4, 0x1) != FC0013_I2C_SUCCESS)
goto error_status_set_registers;
// Set tuner LNA_POWER_DOWN to 0x1.
if(fc0013_SetRegMaskBits(pTuner, 0x6, 0, 0, 0x1) != FC0013_I2C_SUCCESS)
goto error_status_set_registers;
// Wait 100 ms.
pBaseInterface->WaitMs(pBaseInterface, 100);
// Get demod RSSI_R when tuner RSSI calibration is on.
if(pDemod->GetRegBitsWithPage(pDemod, DVBT_RSSI_R, &(pNimExtra->RssiRCalOn)) != FUNCTION_SUCCESS)
goto error_status_get_registers;
// Set tuner EN_CAL_RSSI to 0x0.
if(fc0013_SetRegMaskBits(pTuner, 0x9, 4, 4, 0x0) != FC0013_I2C_SUCCESS)
goto error_status_set_registers;
// Set tuner LNA_POWER_DOWN to 0x0.
if(fc0013_SetRegMaskBits(pTuner, 0x6, 0, 0, 0x0) != FC0013_I2C_SUCCESS)
goto error_status_set_registers;
return FUNCTION_SUCCESS;
error_status_get_registers:
error_status_set_registers:
return FUNCTION_ERROR;
}
//void MxL_Delay(UINT32 mSec)
void MxL_Delay(MxL5007_TunerConfigS* myTuner, UINT32 mSec)
{
TUNER_MODULE *pTuner;
BASE_INTERFACE_MODULE *pBaseInterface;
// Get tuner module and base interface.
pTuner = myTuner->pTuner;
pBaseInterface = pTuner->pBaseInterface;
// Wait in ms.
pBaseInterface->WaitMs(pBaseInterface, mSec);
return;
}
int tua9001waitloop (TUNER_MODULE *pTuner, unsigned int i_looptime)
{
BASE_INTERFACE_MODULE *pBaseInterface;
unsigned long WaitTimeMs;
// Get base interface.
pBaseInterface = pTuner->pBaseInterface;
/* wait time = i_looptime * 1 uS */
// Note: 1. The unit of WaitMs() function is ms.
// 2. WaitTimeMs = ceil(i_looptime / 1000)
WaitTimeMs = i_looptime / 1000;
if((i_looptime % 1000) > 0)
WaitTimeMs += 1;
pBaseInterface->WaitMs(pBaseInterface, WaitTimeMs);
return TUA9001_TUNER_OK;
}
/**
@brief Get register bytes with address.
*/
int
tua9001_GetRegBytesWithRegAddr(
TUNER_MODULE *pTuner,
unsigned char DeviceAddr,
unsigned char RegAddr,
unsigned char *pReadingBytes,
unsigned char ByteNum
)
{
// Get tuner register byte.
//if(rtl2832usb_ReadWithRegAddr(DeviceAddr, RegAddr, pReadingBytes, ByteNum) != FUNCTION_SUCCESS)
// goto error_status_get_tuner_registers_with_address;
I2C_BRIDGE_MODULE *pI2cBridge;
BASE_INTERFACE_MODULE *pBaseInterface;
unsigned char TunerDeviceAddr;
struct dvb_usb_device *d;
// Get I2C bridge.
pI2cBridge = pTuner->pI2cBridge;
pBaseInterface = pTuner->pBaseInterface;
// Get tuner device address.
pTuner->GetDeviceAddr(pTuner,&TunerDeviceAddr);
pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
if( read_rtl2832_tuner_register( d, TunerDeviceAddr, RegAddr, pReadingBytes, ByteNum ) )
goto error_status_get_tuner_registers_with_address;
return FUNCTION_SUCCESS;
error_status_get_tuner_registers_with_address:
return FUNCTION_ERROR;
}
/**
@see DTMB_NIM_FP_IS_SIGNAL_LOCKED
*/
s32
dtmb_nim_default_IsSignalLocked(
DTMB_NIM_MODULE *pNim,
s32 *pAnswer
)
{
BASE_INTERFACE_MODULE *pBaseInterface;
DTMB_DEMOD_MODULE *pDemod;
s32 i;
// Get base interface and demod module.
pBaseInterface = pNim->pBaseInterface;
pDemod = pNim->pDemod;
// Wait for signal lock check.
for(i = 0; i < DTMB_NIM_SINGAL_LOCK_CHECK_TIMES_MAX_DEFAULT; i++)
{
// Wait 20 ms.
pBaseInterface->WaitMs(pBaseInterface, 20);
// Check signal lock status on demod.
// Note: If signal is locked, stop signal lock check.
if(pDemod->IsSignalLocked(pDemod, pAnswer) != FUNCTION_SUCCESS)
goto error_status_execute_function;
if(*pAnswer == YES)
break;
}
return FUNCTION_SUCCESS;
error_status_execute_function:
return FUNCTION_ERROR;
}
/**
@see QAM_NIM_FP_IS_SIGNAL_LOCKED
*/
int
qam_nim_default_IsSignalLocked(
QAM_NIM_MODULE *pNim,
int *pAnswer
)
{
BASE_INTERFACE_MODULE *pBaseInterface;
QAM_DEMOD_MODULE *pDemod;
int i;
// Get base interface and demod module.
pBaseInterface = pNim->pBaseInterface;
pDemod = pNim->pDemod;
// Wait maximum 1000 ms for signal lock check.
for(i = 0; i < DEFAULT_QAM_NIM_SINGAL_LOCK_CHECK_TIMES_MAX; i++)
{
// Wait 20 ms.
pBaseInterface->WaitMs(pBaseInterface, 20);
// Check frame lock status on demod.
// Note: If frame is locked, stop signal lock check.
if(pDemod->IsFrameLocked(pDemod, pAnswer) != FUNCTION_SUCCESS)
goto error_status_execute_function;
if(*pAnswer == YES)
break;
}
return FUNCTION_SUCCESS;
error_status_execute_function:
return FUNCTION_ERROR;
}
/**
@see TUNER_FP_SET_RF_FREQ_HZ
*/
int
gtlp10_SetRfFreqHz(
TUNER_MODULE *pTuner,
unsigned long RfFreqHz
)
{
GTLP10_EXTRA_MODULE *pExtra;
BASE_INTERFACE_MODULE *pBaseInterface;
I2C_BRIDGE_MODULE *pI2cBridge;
unsigned char DeviceAddr;
int i;
unsigned char WritingBytes[LEN_5_BYTE];
unsigned char ReadingBytes[LEN_1_BYTE];
unsigned long Divider;
int LockStatus;
MPI MpiDivider, MpiVar, MpiConst, MpiNone;
long RfFreqHzInt;
// Get tuner extra module and I2C bridge.
pExtra = &(pTuner->Extra.Gtlp10);
pBaseInterface = pTuner->pBaseInterface;
pI2cBridge = pTuner->pI2cBridge;
// Get tuner device address.
pTuner->GetDeviceAddr(pTuner, &DeviceAddr);
// Set DividerMsb and DividerLsb according to RF frequnecy in Hz.
// Note: 1. Origin divider equation:
// Divider = round((RF_freq_MHz + 36.125) / (1 / 6))
// = round((RF_freq_MHz + 36.125) * 6)
// = floor((RF_freq_MHz + 36.125) * 6 + 0.5)
// = floor(((RF_freq_Hz + 36125000 ) * 6 + 500000) / 1000000)
// = floor(((RF_freq_Hz + 36125000) * 3 + 250000) / 500000)
Divider = ((RfFreqHz + 36125000) * 3 + 250000) / 500000;
Divider &= GTLP10_DIVIDER_MASK;
pExtra->DividerMsb = (unsigned char)((Divider >> BYTE_SHIFT) & BYTE_MASK);
pExtra->DividerLsb = (unsigned char)(Divider & BYTE_MASK);
// Set Control2 according to RF frequency in Hz.
if(RfFreqHz < 100000000)
{
pExtra->Control2 = 0x41;
}
else if(RfFreqHz < 122000000)
{
pExtra->Control2 = 0x61;
}
else if(RfFreqHz < 129000000)
{
pExtra->Control2 = 0x81;
}
else if(RfFreqHz < 136000000)
{
pExtra->Control2 = 0xa1;
}
else if(RfFreqHz < 147000000)
{
pExtra->Control2 = 0xc1;
}
else if(RfFreqHz < 240000000)
{
pExtra->Control2 = 0x22;
}
else if(RfFreqHz < 310000000)
{
pExtra->Control2 = 0x42;
}
else if(RfFreqHz < 380000000)
{
pExtra->Control2 = 0x62;
}
else if(RfFreqHz < 430000000)
{
pExtra->Control2 = 0x82;
}
else if(RfFreqHz < 578000000)
{
pExtra->Control2 = 0x84;
}
else if(RfFreqHz < 650000000)
{
pExtra->Control2 = 0xa4;
}
else if(RfFreqHz < 746000000)
{
pExtra->Control2 = 0xc4;
}
else
{
pExtra->Control2 = 0xe4;
}
// Set tuner registers.
WritingBytes[0] = pExtra->DividerMsb;
WritingBytes[1] = pExtra->DividerLsb;
WritingBytes[2] = pExtra->Control1;
WritingBytes[3] = pExtra->Control2;
WritingBytes[4] = pExtra->Control3;
if(pI2cBridge->ForwardI2cWritingCmd(pI2cBridge, DeviceAddr, WritingBytes, LEN_5_BYTE) != FUNCTION_SUCCESS)
goto error_status_set_tuner_registers;
// Wait maximum 100 ms for tuner LO lock.
for(i = 0, LockStatus = NO; i < GTLP10_LO_LOCK_CHECK_TIMES_MAX; i++)
{
// Wait 2 ms.
pBaseInterface->WaitMs(pBaseInterface, 2);
// Check tuner LO lock status.
if(pI2cBridge->ForwardI2cReadingCmd(pI2cBridge, DeviceAddr, ReadingBytes, LEN_1_BYTE) != FUNCTION_SUCCESS)
goto error_status_get_tuner_registers;
if((ReadingBytes[0] & GTLP10_LO_LOCK_MASK) == GTLP10_LO_LOCK_MASK)
{
// LO is locked.
LockStatus = YES;
break;
}
}
// Check tuner LO lock status.
if(LockStatus == NO)
goto error_status_tuner_lo_lock;
// Set tuner RF frequency parameter.
// Note: Origin actual RF frequency equation:
// Actual_RF_freq_Hz = round(Divider * 1000000 * (1 / 6) - 36125000)
// = round(Divider * 1000000 / 6 - 36125000)
// = floor(Divider * 1000000 / 6 - 36125000 + 0.5)
// = floor((Divider * 1000000 - 216750000 + 3) / 6)
// = floor((Divider * 1000000 - 216749997) / 6)
MpiSetValue(&MpiDivider, Divider);
MpiSetValue(&MpiConst, 1000000);
MpiMul(&MpiVar, MpiDivider, MpiConst);
MpiSetValue(&MpiConst, 216749997);
MpiSub(&MpiVar, MpiVar, MpiConst);
MpiSetValue(&MpiConst, 6);
MpiDiv(&MpiVar, &MpiNone, MpiVar, MpiConst);
MpiGetValue(MpiVar, &RfFreqHzInt);
pTuner->RfFreqHz = (unsigned long)RfFreqHzInt;
pTuner->IsRfFreqHzSet = YES;
return FUNCTION_SUCCESS;
error_status_tuner_lo_lock:
error_status_get_tuner_registers:
error_status_set_tuner_registers:
return FUNCTION_ERROR;
}
int tua9001i2cBusWrite (TUNER_MODULE *pTuner, unsigned char deviceAddress, unsigned char registerAddress, char *data,
unsigned int length)
{
#if 0
BASE_INTERFACE_MODULE *pBaseInterface;
unsigned char ByteNum;
unsigned char WritingBytes[I2C_BUFFER_LEN];
unsigned int i;
// Get base interface.
pBaseInterface = pTuner->pBaseInterface;
/* I2C write data format */
/* STA device_address ACK register_address ACK H_Byte-Data ACK L_Byte-Data !ACK STO */
/* STA = start condition, ACK = Acknowledge, STO = stop condition */
/* *data = pointer to data source */
/* length = number of bytes to write */
// Determine byte number.
ByteNum = length + LEN_1_BYTE;
// Determine writing bytes.
WritingBytes[0] = registerAddress;
for(i = 0; i < length; i++)
WritingBytes[LEN_1_BYTE + i] = data[i];
// Send I2C writing command.
if(pBaseInterface->I2cWrite(pBaseInterface, deviceAddress, WritingBytes, ByteNum) != FUNCTION_SUCCESS)
goto error_status_set_tuner_registers;
return TUA9001_TUNER_OK;
error_status_set_tuner_registers:
return TUA9001_TUNER_ERR;
#endif
BASE_INTERFACE_MODULE *pBaseInterface;
unsigned char ByteNum;
unsigned char WritingBytes[I2C_BUFFER_LEN];
unsigned int i=0;
I2C_BRIDGE_MODULE *pI2cBridge;
struct dvb_usb_device *d;
// Get base interface.
pBaseInterface = pTuner->pBaseInterface;
// Get I2C bridge.
pI2cBridge = pTuner->pI2cBridge;
// Get tuner device address.
pBaseInterface->GetUserDefinedDataPointer(pBaseInterface, (void **)&d);
// Determine byte number.
ByteNum = length;
// Determine writing bytes.
//WritingBytes[0] = registerAddress;
for(i = 0; i < length; i++)
WritingBytes[i] = data[i];
// Send I2C writing command.
if( write_rtl2832_tuner_register( d, deviceAddress, registerAddress, WritingBytes, ByteNum ) )
goto error_status_set_tuner_registers;
return TUA9001_TUNER_OK;
error_status_set_tuner_registers:
return TUA9001_TUNER_ERR;
}
