📄 stv0399drv.c
字号:
//sttbx_Print("\nagcGain0I = 0x%x", pbRegValue[0]);
agcGain = STV0399CalcAGC0Gain(pbRegValue[0] & 0x0F)*10;
if (STV0399GetOneRegister( bTunerIndex, STV0399REG_AGC1P, pbRegValue) != CSQPSK_SUCCESS)
return -1;
//sttbx_Print("\nagcGain1P = 0x%x", pbRegValue[0]);
agcGain += STV0399CalcAGC1Gain(pbRegValue[0])*5;
Imin = 0;
Imax = lookup->nSize - 1;
if(InRange(lookup->pTable[Imin].nRegValue,agcGain, lookup->pTable[Imax].nRegValue))
{
while((Imax-Imin)>1)
{
i=(Imax+Imin)/2;
if(InRange(lookup->pTable[Imin].nRegValue,agcGain,lookup->pTable[i].nRegValue))
Imax = i;
else
Imin = i;
}
rfLevel = (((int)agcGain - lookup->pTable[Imin].nRegValue)
* (lookup->pTable[Imax].nRealValue - lookup->pTable[Imin].nRealValue)
/ (lookup->pTable[Imax].nRegValue - lookup->pTable[Imin].nRegValue))
+ lookup->pTable[Imin].nRealValue;
}
else
rfLevel = 0;
}
//sttbx_Print("\nrfLevel = %d", rfLevel);
return rfLevel;
}
/*****************************************************
--FUNCTION :: STV0399GetCarrierToNoiseRatio
--ACTION :: Return the carrier to noise of the current carrier
--PARAMS IN :: NONE
--PARAMS OUT:: NONE
--RETURN :: C/N of the carrier, 0 if no carrier
--***************************************************/
static int STV0399GetCarrierToNoiseRatio( CSHDITunerIndex bTunerIndex, STV0399LookUp_t *lookup)
{
BYTE pbRegValue[4];
int c_n = 0,
nRegValue,
Imin,
Imax,
i;
if (CSQPSK_CF == STV0399GetCFStatus( bTunerIndex))
{
/*TK -testing */
STV0399GetRegisters( bTunerIndex, STV0399REG_NIRH, pbRegValue, 2);
EVM[bTunerIndex] = ((int)pbRegValue[0] << 8) + (int)pbRegValue[1];
/*TK -testing */
if((lookup != NULL) && lookup->nSize)
{
STV0399GetRegisters( bTunerIndex, STV0399REG_NIRH, pbRegValue, 2);
nRegValue = ((int)pbRegValue[0] << 8) + (int)pbRegValue[1];
Imin = 0;
Imax = lookup->nSize - 1;
if(InRange(lookup->pTable[Imin].nRegValue,nRegValue,lookup->pTable[Imax].nRegValue))
{
while((Imax-Imin)>1)
{
i=(Imax+Imin)/2;
if(InRange(lookup->pTable[Imin].nRegValue,nRegValue,lookup->pTable[i].nRegValue))
Imax = i;
else
Imin = i;
}
c_n = ((nRegValue - lookup->pTable[Imin].nRegValue)
* (lookup->pTable[Imax].nRealValue - lookup->pTable[Imin].nRealValue)
/ (lookup->pTable[Imax].nRegValue - lookup->pTable[Imin].nRegValue))
+ lookup->pTable[Imin].nRealValue;
}
else
c_n = 100;
}
}
return c_n;
}
CSQPSK_Error_t STV0399GetError( CSHDITunerIndex bTunerIndex, DWORD * error)
{
int ber = 0, i;
BYTE bACLC, bERRCTRL, bVSTATUS, bFECM;
/*Read registers*/
STV0399GetOneRegister( bTunerIndex, STV0399REG_ACLC, &bACLC);
STV0399GetOneRegister( bTunerIndex, STV0399REG_ERRCNTL, &bERRCTRL);
STV0399GetOneRegister( bTunerIndex, STV0399REG_VSTATUS, &bVSTATUS);
STV0399GetOneRegister( bTunerIndex, STV0399REG_FECM, &bFECM);
for(i=0;i<2;i++)
STV0399GetErrorCount( bTunerIndex, COUNTER1); /* don't remove these lines : they clear undesired values */
/* Average 4 ber values */
for(i=0;i<16;i++)
ber += STV0399GetErrorCount( bTunerIndex, COUNTER1);
ber/=16;
if ( bVSTATUS & STV0399_CF_MASK ) /* Check for carrier */
{
if ((bERRCTRL & STV0399_ERRMODE_MASK) == 0)
{
/* Error Rate */
ber *= 9766;
ber /= (unsigned int)PowOf2(2 + 2 * (bERRCTRL & 0x03)); /* theses two lines => ber = ber * 10^7 */ /*casted to remove compiler warnings*/
switch((bERRCTRL>>2) & 0x03)
{
case 0 : /* QPSK bit errors */
ber /= 8;
switch(bVSTATUS & 0x07)
{
case 0: /* PR 1/2 */
ber *= 1;
ber /= 2;
break;
case 1: /* PR 2/3 */
ber *= 2;
ber /= 3;
break;
case 2: /* PR 3/4 */
ber *= 3;
ber /= 4;
break;
case 3: /* PR 5/6 */
ber *= 5;
ber /= 6;
break ;
case 4: /* PR 6/7 */
ber *= 6;
ber /= 7;
break;
case 5: /* PR 7/8 */
ber *= 7;
ber /= 8;
break;
default :
ber = 0;
break;
}
break;
case 1: /* Viterbi bit errors */
ber /= 8;
break;
case 2: /* Viterbi byte errors */
break;
case 3: /* Packet errors */
if(bFECM & 0x40)
ber *= 147; /* DirecTV */
else
ber *= 204; /* DVB */
break;
}
}
}
*error = (DWORD)ber;
return CSQPSK_SUCCESS;
}
/*****************************************************
--FUNCTION :: GetPolarization
--ACTION :: Get the polarization
--PARAMS IN :: Polarization -> Polarization
--PARAMS OUT:: NONE
--RETURN :: NONE
--***************************************************/
static STV0399Polarization_t STV0399GetPol( CSHDITunerIndex bTunerIndex)
{
BYTE pbRegValue[4];
STV0399Polarization_t polarization;
STV0399GetOneRegister( bTunerIndex, STV0399REG_IOCFG1, pbRegValue);
switch ((pbRegValue[0]>>5) & 0x07)
{
case 0:
polarization = FE_POL_VERTICAL;
break;
case 1:
polarization = FE_POL_HORIZONTAL;
break;
}
return polarization;
}
/*****************************************************
--FUNCTION :: GetBand
--ACTION :: Get the selected local oscillator
--PARAMS IN :: Handle ==> Front End Handle
--PARAMS OUT:: NONE
--RETURN :: selected band
--***************************************************/
static STV0399Bands_t STV0399GetBand( CSHDITunerIndex bTunerIndex)
{
BYTE pbRegValue[4];
STV0399Bands_t band;
STV0399GetOneRegister( bTunerIndex, STV0399REG_IOCFG2, pbRegValue);
switch ((pbRegValue[0]>>4) & 0x01)
{
case 0:
band = FE_BAND_LOW;
break;
case 1:
band = FE_BAND_HIGH;
break;
}
return band;
}
/*****************************************************
--FUNCTION :: STV0399GetSignalInfo
--ACTION :: Return informations on the locked transponder
--PARAMS IN :: Handle ==> Front End Handle
--PARAMS OUT:: pInfo ==> Informations (BER,C/N,power ...)
--RETURN :: Error (if any)
--***************************************************/
CSQPSK_Error_t STV0399GetSignalInfo( CSHDITunerIndex bTunerIndex, STV0399SignalInfo_t *pInfo, STV0399InternalParams_t *pParams)
{
BYTE bPLLFactor;
BYTE pbRegValue[4];
int nDerotFrequency;
int nNIMLockStatus;
int nRTFValue;
// if (1 == STV0399GetLockStatus())
{
STV0399CarrierTracking( bTunerIndex);
if (STV0399GetRegisters ( bTunerIndex, STV0399REG_CFRM, pbRegValue, 2) != CSQPSK_SUCCESS)/* read derotator value */
return CSQPSK_FAILURE;
nDerotFrequency = ((int)pbRegValue[0] << 8) + (int)pbRegValue[1];
if (nDerotFrequency & 0x8000)
nDerotFrequency -= 0x10000;
if (STV0399GetOneRegister ( bTunerIndex, STV0399REG_SYNTCTRL2, pbRegValue) != CSQPSK_SUCCESS)/* read derotator value */
return CSQPSK_FAILURE;
bPLLFactor = ((pbRegValue[0] >> 3) & 0x01) + 4;
if (STV0399GetOneRegister ( bTunerIndex, STV0399REG_RTF, pbRegValue) != CSQPSK_SUCCESS)/* read derotator value */
return CSQPSK_FAILURE;
nRTFValue = (int)pbRegValue[0];
if (nRTFValue & 0x80)
nRTFValue -= 0x100;
/* transponder_frequency = synthe_frequency*PLL_factor + derotator_frequency */
pInfo->Frequency = abs((STV0399GetSyntFreq( bTunerIndex, pParams->Quartz) * (int)bPLLFactor + (nDerotFrequency * pParams->Mclk))/1000);
//sttbx_Print("\n[Frequency: %d]", pInfo->Frequency);
pInfo->SymbolRate = STV0399GetSymbolRate( bTunerIndex, pParams->MasterClock); /* Get symbol rate */
pInfo->SymbolRate += (pInfo->SymbolRate*nRTFValue)>>19; /* Get timing loop offset */
// print("\n[Symbol Rate: %d]", pInfo->SymbolRate);
pInfo->Polarization = STV0399GetPol( bTunerIndex);
// print("\n[Polarization: %d]", pInfo->Polarization);
pInfo->Band = STV0399GetBand( bTunerIndex);
// print("\n[Band: %d]", pInfo->Band);
STV0399GetOneRegister( bTunerIndex, STV0399REG_VSTATUS, pbRegValue);
pInfo->Rate = 1 << (pbRegValue[0] & 0x07);
// print("\n[Rate: %d]", pInfo->Rate);
if(g_Tuner_Type[bTunerIndex] == STV0399_E)
pInfo->Power = STV0399GetRFLevel( bTunerIndex, &STV0399ERFLookUp)+(pInfo->Frequency-950000)/10000; /* correction applied according to RF frequency */
else
pInfo->Power = STV0399GetRFLevel( bTunerIndex, &STV0399RFLookUp)+(pInfo->Frequency-950000)/10000; /* correction applied according to RF frequency */
//sttbx_Print("\n[Power: %d]", pInfo->Power);
if(g_Tuner_Type[bTunerIndex] == STV0399_E)
pInfo->C_N = STV0399GetCarrierToNoiseRatio( bTunerIndex, &STV0399ECN_LookUp);
else
pInfo->C_N = STV0399GetCarrierToNoiseRatio( bTunerIndex, &STV0399CN_LookUp);
// print("\n[C_N: %d]", pInfo->C_N);
STV0399GetError( bTunerIndex, &pInfo->BER);
// print("\n[BER: %d]", pInfo->BER);
/*retrieves the modulation from the R8PSK register-> value 0 indicates QPSK, Value 1 indicates 8PSK*/
// tempvar = ChipGetField(pParams->hChip,F399_MODE_8PSK);
STV0399GetOneRegister( bTunerIndex, STV0399REG_R8PSK, pbRegValue);
if(pbRegValue[0] & STV0399_MODE_8PSK_MASK)
pInfo->Modulation = STTUNER_MOD_8PSK;
else
pInfo->Modulation = STTUNER_MOD_QPSK;
// print("\n[Modulation: %d]", pInfo->Modulation);
STV0399GetOneRegister( bTunerIndex, 0X39, pbRegValue);
// print("\n[Register[0x39] = 0x%x]", pbRegValue[0]);
STV0399GetOneRegister( bTunerIndex, 0X3a, pbRegValue);
// print("\n[Register[0x3a] = 0x%x]", pbRegValue[0]);
return CSQPSK_SUCCESS;
}
// else
// return FAILURE;
}
CSQPSK_Error_t STV0399GetSignalquality( CSHDITunerIndex bTunerIndex , int *Quality)
{
int nC_N;
int nQuality;
int i;
int status;
STV0399CarrierTracking( bTunerIndex);
STV0399GetLockStatus( bTunerIndex, &status);
if ( status == TRUE)
{
if ( g_Tuner_Type[bTunerIndex] == STV0399_E )
{
nC_N = STV0399GetCarrierToNoiseRatio( bTunerIndex, &STV0399ECN_LookUp);
for(i=0; i<20; ++i)
{
if(STV0399ESignalQuality_LookUp[i][0] >= nC_N)
{
nQuality = STV0399ESignalQuality_LookUp[i][1];
break;
}
}
}
else
{
nC_N = STV0399GetCarrierToNoiseRatio( bTunerIndex, &STV0399CN_LookUp);
for(i=0; i<20; ++i)
{
if(STV0399SignalQuality_LookUp[i][0] >= nC_N)
{
nQuality = STV0399SignalQuality_LookUp[i][1];
break;
}
}
}
}
else
{
nQuality = 10;
}
*Quality=nQuality;
return CSQPSK_SUCCESS;
}
CSQPSK_Error_t STV0399GetSignalLevel( CSHDITunerIndex bTunerIndex , int *Strength)
{
int nPower;
STV0399SignalInfo_t pT_Info;
BYTE bValue;
BYTE bPLLFactor;
BYTE pbRegValue[4];
int nDerotFrequency;
int status;
//STV0399GetSignalInfo(&pT_Info, &g_pT_Params);
if (STV0399GetRegisters ( bTunerIndex, STV0399REG_CFRM, pbRegValue, 2) != CSQPSK_SUCCESS)/* read derotator value */
{
*Strength = 0;
return CSQPSK_FAILURE;
}
nDerotFrequency = ((int)pbRegValue[0] << 8) + (int)pbRegValue[1];
if (nDerotFrequency & 0x8000)
nDerotFrequency -= 0x10000;
if (STV0399GetOneRegister ( bTunerIndex, STV0399REG_SYNTCTRL2, pbRegValue) != CSQPSK_SUCCESS)/* read derotator value */
{
*Strength = 0;
return CSQPSK_FAILURE;
}
bPLLFactor = ((pbRegValue[0] >> 3) & 0x01) + 4;
/* transponder_frequency = synthe_frequency*PLL_factor + derotator_frequency */
pT_Info.Frequency = abs((STV0399GetSyntFreq(bTunerIndex, g_pT_Params[bTunerIndex].Quartz) * (int)bPLLFactor + (nDerotFrequency * g_pT_Params[bTunerIndex].Mclk))/1000);
if(g_Tuner_Type[bTunerIndex] == STV0399_E)
pT_Info.Power = STV0399GetRFLevel( bTunerIndex, &STV0399ERFLookUp)+(pT_Info.Frequency-950000)/10000; /* correction applied according to RF frequency */
else
pT_Info.Power = STV0399GetRFLevel( bTunerIndex, &STV0399RFLookUp)+(pT_Info.Frequency-950000)/10000; /* correction applied according to RF frequency */
STV0399GetLockStatus( bTunerIndex, &status);
if ( status == TRUE)
{
nPower = (pT_Info.Power + 1060) / 10;
}
else
{
STV0399GetOneRegister( bTunerIndex, STV0399REG_AGC0I, &bValue);
if(bValue>=8)
{
nPower = 20;
}
else
{
nPower = (pT_Info.Power + 1060) / 10;
}
}
if(nPower > 100)
nPower = 20;
*Strength = nPower;
return CSQPSK_SUCCESS;
}
/*****************************************************
**FUNCTION :: STV0399GetVcoState
**ACTION :: return the status of the VCO
**PARAMS IN :: hChip ==> handle to the chip
**PARAMS OUT:: NONE
**RETURN :: the current state of the VCO, -1 FOR failure
*****************************************************/
static int STV0399GetVcoState ( CSHDITunerIndex bTunerIndex)
{
BYTE bSysCtrlReg;
int nVCOState = VCO_LOCKED;
if (STV0399GetOneRegister ( bTunerIndex, STV0399REG_SYSCTRL, &bSysCtrlReg) != CSQPSK_SUCCESS)
return -1;
if ((bSysCtrlReg & STV0399_VLOW_MASK) == 0) /* VCO is too low */
nVCOState = VCO_TOO_LOW;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -