📄 cx24143drv.c
字号:
*status=1; //fail
CSTRACE(ERROR_LEVEL,"[HDI][CS_QPSK]SBRead error \n");
CS_CNXT_REGMAP_SET( CS_PLL_PAD_FAST_CTRL_REG, CS_PLL_FAST_CTRL_DEMOD_CONNECT_SEL_MASK,
CS_PLL_FAST_CTRL_DEMOD_CONNECT_ASX );
return 0;
}
else
*status=0;
#endif
CS_CNXT_REGMAP_SET( CS_PLL_PAD_FAST_CTRL_REG, CS_PLL_FAST_CTRL_DEMOD_CONNECT_SEL_MASK,
CS_PLL_FAST_CTRL_DEMOD_CONNECT_ASX );
}
else
{
reg_value = *(ULPREG)CS_DEMOD_REG_TO_ASX_ADDR(reg_addr);
*status = 0; /* indicate success */
}
#endif
return reg_value;
}
// here mybe bug ,sfg, It will lost lock when CSSleep time is short
// OS_Wait() will call it. so be carefull.
static BOOL NIM_Wait( NIM *nim, int waitms )
{
int nReturn;
// task_time_sleep( waitms );
// CSSleep((DWORD) waitms*2);// 2 //Jeffrey
// CSSleep_ex(waitms);
#if 0
nReturn = CSQPSKSleep(0,waitms);
if ( CSQPSK_DROPPED == nReturn )
{
CSTRACE( INFO_LEVEL, "\n[CS_QPSK] QUICK EXIT wait\n");
return FALSE;
}
#else
//CSSleep_ex(waitms);
CSSleep((DWORD) waitms*2+5);
#endif
return TRUE;
}
static CSQPSK_Error_t CX2414X_get_signal_stats( ULONG unit, SIGNAL_STATS *signal_stats ,BOOL strength_flag)
{
AGCACC agcacc;
CMPLXNO esno;
MSTATUS status;
// extern DWORD g_dwNIMState[MAX_TUNER_NUM];
int LockStatus=0;
LOCKIND lockinds;
if ( !demod_initfalg )
{
//CSTRACE( ERROR_LEVEL, "[CS_QPSK] demod has not been initialized\n" );
return CSQPSK_DEVICE_UNKNOWN;
}
signal_stats->signal_strength = 0;
signal_stats->signal_quality = 0;
signal_stats->type = DEMOD_NIM_SATELLITE;
if (API_GetLockIndicators(&NIMs[unit],&lockinds) == False)
return CSQPSK_FAILURE;
// CX2414xCheckLockStatus ( unit, &LockStatus);
// if ( local_state[unit] == CONNECTED )
// if (g_dwNIMState[unit] == CONNECTED )
// if(LockStatus == 1)
#ifdef QPSK_DEBUG
//CSTRACE(QPSK_DEBUG_LEVEL,"[CX2414X_get_signal_stats]lockinds.syncbyte=%d\n",lockinds.syncbyte);
#endif
if(lockinds.syncbyte ==1 )
{
/* Get the power level from the AGC accumulator */
if(strength_flag==1){
if ( !API_GetAGCAcc( &NIMs[unit], &agcacc ) )
{
//CSTRACE( QPSK_DEBUG_LEVEL, "[CS_QPSK]API_GetAGCAcc fail\n" );
return CSQPSK_FAILURE;
}
else
{
/* AGCACC is signed, from -128 to 127. Convert to 0 to 255. */
signal_stats->signal_strength = 128 + agcacc;
}
// CSTRACE( INFO_LEVEL, "[CS_QPSK]API_GetChannelEsNo signal_strength=%d\n" ,signal_stats->signal_strength);
return CSQPSK_SUCCESS;
}
/* Get the quality from the error rate. */
if ( !API_GetChannelEsNo( &NIMs[unit], ESNOMODE_SNAPSHOT, &esno, &status ) )
{
//CSTRACE( QPSK_DEBUG_LEVEL, "[CS_QPSK]API_GetChannelEsNo failed\n" );
return CSQPSK_FAILURE;
}
else
{
/* If measurement not done, report an error. */
#if 1// remove it by sfg
if ( status == MSTATUS_NOTDONE )
{
//CSASSERT(!status);
//CSTRACE( QPSK_DEBUG_LEVEL, "[CS_QPSK]API_GetChannelEsNo status =MSTATUS_NOTDONE\n" );
return CSQPSK_FAILURE;
}
#endif
signal_stats->signal_quality = (((esno.integer-20)*256)/181);
// CSTRACE( INFO_LEVEL, "[CS_QPSK]API_GetChannelEsNo signal_quality=%d\n" ,signal_stats->signal_quality);
}
}
return CSQPSK_SUCCESS;
}
void CX2414XAGCMode(CSHDITunerIndex bTunerIndex, int nMode)
{
if (nMode == 0) /* positive */
{
CX2414XWriteReg( bTunerIndex, 0x3e, 0x00);
}
else /* negative */
{
CX2414XWriteReg( bTunerIndex, 0x3e, 0x10);
}
}
void CX2414XSetRepeatMode(CSHDITunerIndex bTunerIndex)
{
BYTE ucData;
CX2414XReadReg( bTunerIndex, 0x23, &ucData);
ucData |= 0x20;
CX2414XWriteReg( bTunerIndex, 0x23, ucData);
}
void CX2414XEnableRepeatMode(CSHDITunerIndex bTunerIndex, BYTE ucMode)
{
BYTE ucData;
BYTE aucData[4];
HCSHANDLE hTunerHanele;
/*Enable repeat*/
CX2414XReadReg( bTunerIndex, 0x23, &ucData);
ucData &= 0x7F;
CX2414XWriteReg( bTunerIndex, 0x23, ucData);
if ( ucMode == 1)
{
ucData |= 0x40;
}
else
{
ucData &= 0xb0;
}
CX2414XWriteReg( bTunerIndex, 0x23, ucData);
}
void CX2414XCheckTunerType(CSHDITunerIndex bTunerIndex)
{
int nResult, nTmp;
Sharp0302aInit(bTunerIndex);
nResult = Sharp0302aCheckTuner(bTunerIndex);
if (nResult == TRUE)
{
g_ucCx2414xTunerType[bTunerIndex] = CX2414X_TUNER_SHARP0302;
CSTRACE(INFO_LEVEL, "[HDIQPSK]tuner is SHARP 0302\r\n");
}
else
{
Sharp0302aTerm(bTunerIndex);
CX2414XEnableRepeatMode(bTunerIndex, 0);
g_ucCx2414xTunerType[bTunerIndex] = CX2414X_TUNER_CX24109;
CSTRACE(INFO_LEVEL, "[HDIQPSK]tuner is CX24109\r\n");
}
}
BYTE CX2414XGetTunerType(CSHDITunerIndex bTunerIndex)
{
return g_ucCx2414xTunerType[bTunerIndex];
}
static CSQPSK_Error_t CX2414X_demod_init(CSHDITunerIndex bTunerIndex )
{
BOOL demod_retval;
LNBMODE lnbmode;
TRANSPEC transpec;
ULONG stat;
/* If there is an onboard demod, make sure it has not been disabled
before trying to use it. */
if ( CS_CNXT_REGMAP_GET( CS_PLL_TEST_REG, CS_PLL_TEST_DEMOD_DISABLE_MASK ) ==
CS_PLL_TEST_DEMOD_DISABLED )
{
CSTRACE( ERROR_LEVEL, "[HDIQPSK] DEMOD_NO_HARDWARE\n");
return CSQPSK_DEVICE_UNKNOWN;//DEMOD_NO_HARDWARE;
}
/* Set up the access method for the internal demod based on the
configuration settings. */
CS_CNXT_REGMAP_SET( CS_PLL_PAD_FAST_CTRL_REG, CS_PLL_FAST_CTRL_DEMOD_CONNECT_SEL_MASK,
CS_PLL_FAST_CTRL_DEMOD_CONNECT_ASX );
CS_CNXT_REGMAP_SET( CS_PLL_PAD_FAST_CTRL_REG, CS_PLL_FAST_CTRL_DEMOD_I2C_SEL_MASK,
CS_PLL_FAST_CTRL_DEMOD_I2C_BUS_0 );
demod_handle[0] = CS_I2C_ADDR_CAMARO;
// demod_handle[1] = 0x10000 | CS_I2C_ADDR_CAMARO;
/* workaround to try to keep Camaro powered up and clocked on Brazos A */
// SBWrite( demod_handle[0], 0xff, 0x39, &stat );
// SBWrite( demod_handle[0], 0xef, 0x00, &stat );
// SBWrite( demod_handle[0], 0x67, 0x80, &stat );
CX2414XWriteReg( bTunerIndex, 0xff, 0x39 );
CX2414XWriteReg( bTunerIndex, 0xef, 0x00 );
CX2414XWriteReg( bTunerIndex, 0x67, 0x80 );
//task_time_sleep(1000);
CSSleep_ex(1000);
/* Configure output mode. */
MPEG.OutputMode = PARALLEL_OUT;
MPEG.ClkOutEdge = CLKOUT_SETUP3_HOLD5;
MPEG.ClkParityMode = CLK_CONTINUOUS;
MPEG.HoldTime = SMALL_HOLD_TIME;
MPEG.StartSignalPolarity = ACTIVE_HIGH;
MPEG.StartSignalWidth = BYTE_WIDE;
MPEG.ValidSignalPolarity = ACTIVE_HIGH;
MPEG.ValidSignalActiveMode = ENTIRE_PACKET;
MPEG.FailSignalPolarity = ACTIVE_HIGH;
MPEG.FailSignalActiveMode = FIRST_BYTE;
MPEG.SyncPunctMode = SYNC_WORD_NOT_PUNCTURED;
MPEG.FailValueWhenNoSync = FAIL_HIGH_WHEN_NO_SYNC;
MPEG.ClkSmoothSel = CLK_SMOOTHING_OFF;
MPEG.RSCntlPin1Sel = RS_CNTLPIN_START;
MPEG.RSCntlPin2Sel = RS_CNTLPIN_VALID;
MPEG.RSCntlPin3Sel = RS_CNTLPIN_FAIL;
MPEG.NullDataMode = FIXED_NULL_DATA_DISABLED;
MPEG.NullDataValue = FIXED_NULL_DATA_LOW;
MPEG.ValidSignalWhenFail = VALID_SIGNAL_INACTIVE_WHEN_FAIL;
MPEG.StartSignalWhenFail = START_SIGNAL_INACTIVE_WHEN_FAIL;
MPEG.ParityDataSel = RS_PARITY_DATA_UNCHANGED;
#ifdef USE_LNB_22KHZ_TONE
lnbmode.tone_clock = 115;
lnbmode.cycle_count = 0;
lnbmode.lnb_mode = LNBMODE_TONE;
#else
lnbmode.tone_clock = 0;
lnbmode.cycle_count = 0;
lnbmode.lnb_mode = LNBMODE_MANUAL_ZERO;
#endif
if ( MPEG.OutputMode != PARALLEL_OUT )
{
CSTRACE( ERROR_LEVEL, "[HDIQPSK] DEMOD_ERROR\n");
return CSQPSK_FAILURE;//DEMOD_ERROR;
}
/* Set the transport specification. If the demod is on-board, it can do
either DVB or DSS automagically. If the demod is not on-board, set it
to do only DVB. */
#if (CS_DEMODE_TYPE == CX_BUILDIN_DEMOD)
transpec = SPEC_DVB_DSS;
#else
transpec = SPEC_DVB;
#endif
#if (CS_DEMODE_TYPE == CX_BUILDIN_DEMOD)
/* perform an internal soft reset */
// SBWrite( demod_handle[0], 0, 0xff, &stat );
// SBWrite( demod_handle[0], 0, 0, &stat );
CX2414XWriteReg( bTunerIndex, 0, 0xff );
CX2414XWriteReg( bTunerIndex, 0, 0 );
#endif
/* do the low level initialization */
demod_retval = API_InitEnvironment( &NIMs[0], demod_handle[0], SBWrite, SBRead, transpec, 0, 10111000, True, &MPEG, &lnbmode, &NIM_Wait );
CSASSERT(demod_retval);
if ( !demod_retval )
{
CSTRACE( ERROR_LEVEL, "[HDIQPSK] DEMOD_ERROR 2\n");
return CSQPSK_FAILURE;//DEMOD_ERROR;
}
/* initialization for DiSEqC 2.x */
#ifdef INCLUDE_DISEQC2
demod_retval = API_DiseqcSetVersion( &NIMs[0], DISEQC_VER_2X);
if ( !demod_retval )
{
CSTRACE( ERROR_LEVEL, "[HDIQPSK] DEMOD_ERROR 3\n");
return CSQPSK_FAILURE;//DEMOD_ERROR;
}
#endif
#if (CS_DEMODE_TYPE == CX_BUILDIN_DEMOD)
/* workaround to try to keep Camaro powered up and clocked on Brazos A */
// SBWrite( demod_handle[0], 0xff, 0x39, &stat );
// SBWrite( demod_handle[0], 0xef, 0x00, &stat );
// SBWrite( demod_handle[0], 0x67, 0x80, &stat );
CX2414XWriteReg( bTunerIndex, 0xff, 0x39);
CX2414XWriteReg( bTunerIndex, 0xef, 0x00 );
CX2414XWriteReg( bTunerIndex, 0x67, 0x80 );
//task_time_sleep(1000);
CSSleep_ex(1000);
#endif
#if (CS_DEMODE_TYPE == CX_BUILDIN_DEMOD)
/* API_InitEnvironment calls API_SetOutputIO to set up MPEG output control
register 3. Unfortunately, API_SetOutputIO has not yet been updated to
understand that Camaro has 3 RS_CNTL pins, versus only 2 for external
demods. Write directly to the register to initialize all three signals.
When API_SetOutputIO is updated, change to use it. */
// SBWrite( demod_handle[0], 0x06, 0x21, &stat );
CX2414XWriteReg( bTunerIndex, 0x06, 0x21);
#endif
// sfg setup last save lnb
CX2414X_lnb_init( TRUE);// init lnb power control when power up
/* Set the Cobra demod interrupt options to no interrupts. */
API_SetInterruptOptions( &NIMs[0], COBRA_NO_INTERRUPTS );
/* Try to clear any currently pending Cobra demod interrupts. */
API_ClearPendingInterrupts( &NIMs[0] );
return CSQPSK_SUCCESS;//DEMOD_SUCCESS;
}
/*****************************************************************************/
/* FUNCTION: CX2414xCheckLockStatus */
/* PARAMETERS: pnLockStatus - the tuner lock status.
bTunerIndex - tuner index
*/
/* DESCRIPTION: This function Check tuner Lock Status. */
/* RETURNS: lock -- suceess. others -- failure */
/*****************************************************************************/
CSQPSK_Error_t CX2414xCheckLockStatus ( CSHDITunerIndex bTunerIndex, int *pnLockStatus )
{
LOCKIND lockinds;
int i;
*pnLockStatus = FALSE;
//for(i=0;i<3;i++)
{
if (API_GetLockIndicators(&NIMs[bTunerIndex],&lockinds) == False)
{
//CSSleep_ex(5);
//continue;
return CSQPSK_FAILURE;
}
if(lockinds.syncbyte)
{
*pnLockStatus = lockinds.syncbyte;
//break;
}
//else
// CSSleep_ex(5);
}
// if(*pnLockStatus==0)
// CSTRACE( ERROR_LEVEL, "[HDIQPSK] CX2414x lock register value =0x%x , lock when MSB bit=1 \n",lockinds);
// if(*pnLockStatus)
// CSTRACE( ERROR_LEVEL, "[HDIQPSK] CX2414x demod lock \n");
// if(lockinds.reedsolomon)
// CSTRACE( ERROR_LEVEL, "[HDIQPSK] CX2414x reedsolomon lock \n");
// if(lockinds.viterbi)
// CSTRACE( ERROR_LEVEL, "[HDIQPSK] CX2414x viterbi lock \n");
// if(lockinds.demod_pll)
// CSTRACE( ERROR_LEVEL, "[HDIQPSK] CX2414x demod_pll lock \n");
// if(lockinds.descramble)
// CSTRACE( ERROR_LEVEL, "[HDIQPSK] CX2414x descramble lock \n");
// if(lockinds.pll)
// CSTRACE( ERROR_LEVEL, "[HDIQPSK] CX2414x tuner pll lock \n");
// if(*pnLockStatus)
// CSTRACE( ERROR_LEVEL, "******[HDIQPSK] CX2414x full lock !!!!!\n");
// else
// CSTRACE( ERROR_LEVEL, "#####[HDIQPSK] CX2414x lost lock?????? \n");
return (CSQPSK_SUCCESS);
}
/*****************************************************************************/
/* FUNCTION: CX2414xSignalQuality */
/* PARAMETERS: bTunerIndex - tuner index
pnSignalQuality - the current Signal Quality.
*/
/* DESCRIPTION: This function Check tuner Signal Quality. */
/* RETURNS: suceess or failure */
/*****************************************************************************/
CSQPSK_Error_t CX2414xSignalQuality(CSHDITunerIndex bTunerIndex, int *pnSignalQuality )
{
CSQPSK_Error_t ret_err;
SIGNAL_STATS signal_stats;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -