stv0288drv.c

来自「QPSK Tuner details, for conexant chipset」· C语言 代码 · 共 2,124 行 · 第 1/5 页

C
2,124 行
字号
12345

CSQPSK_Error_t STV0288ConfigTSOutMode (CSHDITunerIndex bTunerIndex, int nTSOutMode)
{
	if ((TS_PARALLEL == nTSOutMode) || (TS_SERIAL == nTSOutMode))
	{
		g_nTSOutputMode[bTunerIndex] = nTSOutMode;
                
		return CSQPSK_SUCCESS;
	}
	else
		return CSQPSK_INVALID_PARAM;
}

static CSQPSK_Error_t STV0288Init(CSHDITunerIndex bTunerIndex)
{
	int ErrorCode;	
	
	g_hSTV0288I2C[bTunerIndex] = 0;
	ErrorCode = CSI2COpen(bTunerIndex,STV0288_CHIP_ADDR,&g_hSTV0288I2C[bTunerIndex]);
	CSASSERT(ErrorCode == CSI2C_SUCCESS);
	if ( ErrorCode != CSI2C_SUCCESS)
	{
		return CSQPSK_I2C_ERROR;
	}
	
	return CSQPSK_SUCCESS;
}
/* +==========================================================================+ */
/* | Function:	OrSTV0288P4J}>]												  |	*/		
/* | Input:		FpJ<<D4fFwKwR}:E											  |	*/
/* | 			V8OrJ}>]5DV8Uk												  |	*/
/* | 			4}P4HkJ}>]8vJ}												  |	*/
/* | Output:	N^															  |	*/
/* | Return:	P4Hk3I9&1jV>												  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0288WrtReg ( CSHDITunerIndex bTunerIndex, BYTE StartReg, BYTE *pbValue, DWORD dwLength )
{
	DWORD ii;
	int ErrorCode;
	BYTE bValue[0x80];

	if(dwLength>=0x80)
	{
		CSTRACE(ERROR_LEVEL,"[hdi][qpsk]STV0288WrtReg input param error \n");
		return CSQPSK_INVALID_PARAM;
	}
	if ( NULL ==pbValue )
	{
		CSASSERT ( NULL !=pbValue );
		return CSQPSK_INVALID_PARAM;
	}
	bValue[0] = StartReg;

	for ( ii = 1; ii < dwLength+1; ii++ )
		bValue[ii] = *pbValue++;

	if ( CSI2CRequestBus_inner(bTunerIndex, CSHDI_TIMEOUT_INFINITY) == CSI2C_SUCCESS )
	{
		ErrorCode = CSI2CWriteWithStop ( g_hSTV0288I2C[bTunerIndex], bValue, dwLength+1) ;  
		if (ErrorCode == CSI2C_SUCCESS)
			STV0288Set_RegMap_Val( StartReg, &bValue[1],  dwLength);
		CSI2CReleaseBus_inner(bTunerIndex);
		if (ErrorCode == CSI2C_SUCCESS)
		{
			return CSQPSK_SUCCESS;
		}
	}

	return CSQPSK_I2C_ERROR;
}	


CSQPSK_Error_t STV0288WriteReg ( CSHDITunerIndex bTunerIndex, BYTE StartReg, BYTE *pbValue, DWORD dwLength )
{
	DWORD ii;
	int ErrorCode;
	BYTE bValue[0x80];

	if(dwLength>=0x80)
	{
		CSTRACE(ERROR_LEVEL,"[hdi][qpsk]STV0288WrtReg input param error \n");
		return CSQPSK_INVALID_PARAM;
	}

	bValue[0] = StartReg;

	for ( ii = 1; ii < dwLength+1; ii++ )
		bValue[ii] = *pbValue++;

	ErrorCode = CSI2CWriteWithStop ( g_hSTV0288I2C[bTunerIndex], bValue, dwLength+1) ;  
	if (ErrorCode!=CSI2C_SUCCESS)
	{
		return CSQPSK_I2C_ERROR;
	}
	STV0288Set_RegMap_Val( StartReg, &bValue[1],  dwLength);
	return CSQPSK_SUCCESS;
}	


/* +==========================================================================+ */
/* | Function:	4SSTV02886AR;4.J}>]											  |	*/		
/* | Input:		FpJ<<D4fFwKwR}:E											  |	*/
/* | 			V8OrJ}>]5DV8Uk												  |	*/
/* | 			4}6AHkJ}>]8vJ}												  |	*/
/* | Output:	6A3v5DJ}>]													  |	*/
/* | Return:	P4Hk3I9&1jV>												  |	*/
/* +==========================================================================+ */

CSQPSK_Error_t STV0288RdReg(CSHDITunerIndex bTunerIndex, BYTE bStartReg, BYTE *pbValue, DWORD dwLength )
{
	int nResult= CSQPSK_SUCCESS;
	BYTE bValue;

	if ( NULL ==pbValue )
	{
		CSASSERT ( NULL != pbValue );
		return CSQPSK_INVALID_PARAM;
	}
	if ( CSI2CRequestBus_inner(bTunerIndex, CSHDI_TIMEOUT_INFINITY) == CSI2C_SUCCESS )
	{
		bValue = bStartReg;

		if ( CSI2CWriteWithStop ( g_hSTV0288I2C[bTunerIndex], &bValue, 1 ) != CSI2C_SUCCESS ) 
			nResult = CSQPSK_I2C_ERROR;

		if ( CSI2CReadWithStop (g_hSTV0288I2C[bTunerIndex], pbValue, dwLength ) !=CSI2C_SUCCESS )
			nResult = CSQPSK_I2C_ERROR;

		CSI2CReleaseBus_inner(bTunerIndex);
	}
	else
		nResult = CSQPSK_I2C_ERROR;

	return nResult;
}	
// end STV0288RdReg()
CSQPSK_Error_t STV0288ReadReg(CSHDITunerIndex bTunerIndex, BYTE bStartReg, BYTE *pbValue, DWORD dwLength )
{
	int nResult= CSQPSK_SUCCESS ;
	BYTE bValue;

	bValue = bStartReg;
	if ( CSI2CWriteWithStop ( g_hSTV0288I2C[bTunerIndex], &bValue, 1 ) != CSI2C_SUCCESS ) 
		nResult = CSQPSK_I2C_ERROR;

	if ( CSI2CReadWithStop (g_hSTV0288I2C[bTunerIndex], pbValue, dwLength ) !=CSI2C_SUCCESS )
		nResult = CSQPSK_I2C_ERROR;

	return nResult;
}	


/* +==========================================================================+ */
/* | Function:	?XVFF22R}=EJd3v22KV\FZPE:E									  |	*/		
/* | Input:		?XVFJdHk ( F22KON / F22KOFF )								  |	*/
/* | Output:	N^															  |	*/
/* | Return:	P4Hk3I9&1jV>												  |	*/
/* +==========================================================================+ */

CSQPSK_Error_t STV0288F22KSwitch ( CSHDITunerIndex bTunerIndex, CSHDISwitch nF22KCtrl )
{
	BYTE bValue;
	//CSTRACE( INFO_LEVEL, "\n[F22KSwitch]F22KSwitch enter!!!!\r\n");

	STV0288RdReg( bTunerIndex,R288_DISEQC, &bValue, 1 );
	bValue &= 0xfc;

	if ( nF22KCtrl == CSHDI_ON)
	{
		bValue |=  0x00 ;
	}
	else 
	{
		bValue |=  0x03 ;
	}
	STV0288WrtReg (bTunerIndex,R288_DISEQC, &bValue, 1);
	return CSQPSK_SUCCESS;
}

static CSQPSK_Error_t DiSEqCF22KSwitch ( CSHDITunerIndex bTunerIndex, CSHDISwitch nF22KCtrl )
{
	BYTE bValue;

       // CSTRACE( INFO_LEVEL, "\n=========Enter DiSEqCF22KSwitch=============");
	// CSTRACE( INFO_LEVEL, "\nnF22KCtrl = %d",nF22KCtrl);
#if 0		
	if ( nF22KCtrl == CSHDI_ON )
		bValue = F22K_CONTINUOUS ;
	else 
		bValue = F22K_LOW ;


      // CSTRACE( INFO_LEVEL, "\n========================================\n");
	return ( STV0288WriteReg ( bTunerIndex,STV0288REG_DiSEqC, &bValue, 1 ) );
#else
	return CSQPSK_SUCCESS;
#endif
}

CSQPSK_Error_t STV0288GetMasterClock ( void )
{
	BYTE bPLL_Rate,bPLL_Selration, bpll_bypass, bValue;
	DWORD dExt_clk=STV0288_EXT_REF_CLOCK;  //xtal
	
	STV0288Get_RegMap_Val(R288_PLLCTRL,&bPLL_Rate,1);
	STV0288Get_RegMap_Val(R288_SYNTCTRL,&bValue,1);
	bpll_bypass=bValue&0x01;
	bValue &=0x04;
	bPLL_Selration =  (bValue) ? 4 : 6;
	if(bpll_bypass)
	{
		g_dwMaster_Clock_Khz=dExt_clk;
	}
	else
	{
		g_dwMaster_Clock_Khz=(dExt_clk*(bPLL_Rate+1))/bPLL_Selration;
	}
	CSTRACE(INFO_LEVEL,"\n [STV0288GetMasterClock]Master clock =%d khz\n",g_dwMaster_Clock_Khz);
	CSASSERT( 0 !=g_dwMaster_Clock_Khz);
	return CSQPSK_SUCCESS;
}
/* +==========================================================================+ */
/* | Function:	STV0288KySP<D4fFw3uJ<;/										  |	*/		
/* | Input:		N^														      |	*/
/* | Output:	N^															  |	*/
/* | Return:	P4Hk3I9&1jV>												  |	*/
/* +==========================================================================+ */
void vDebug_Regisger_Value(CSHDITunerIndex bTunerIndex)
{
	BYTE bValue[0x80];
	int i;
	STV0288RdReg( bTunerIndex, 0,bValue, 0x7f);
	 CSTRACE(ERROR_LEVEL,"\n");
	for (i=0;i<0x80;i++)
	{
		CSTRACE(ERROR_LEVEL,"[0x%02x]=0x%02x ",i, bValue[i]);
		if ((i+1)%10==0) CSTRACE(ERROR_LEVEL,"\n");
	}
	 CSTRACE(ERROR_LEVEL,"\n     \n");
	
	for (i=0;i<0x80;i++)
	{
		CSTRACE(ERROR_LEVEL,"[Mx%02x]=0x%02x ",i, g_Stv0288RegMapVal[i]);
		if ((i+1)%10==0) CSTRACE(ERROR_LEVEL,"\n");
	}
	
}
CSQPSK_Error_t STV0288RegInit ( CSHDITunerIndex bTunerIndex )
{
	// sfg DWORD dwDataLen = 0x35;
	BYTE b22KStatus ;
	BYTE bValue[STV0288_NUM_REGS];
	int ErrorCode = CSQPSK_SUCCESS;

	STV0288RegMap_DefaultVal();
	ErrorCode |=STV0288STDBY (  bTunerIndex,0 );
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_ID, 		&g_Stv0288DefVal[0], 29 ) ;
       ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_TLIRM, 		&g_Stv0288DefVal[29], 42 ) ;
       ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_SYMBCTRL, 	&g_Stv0288DefVal[71], 3 ) ;
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_ASCTRL, 	&g_Stv0288DefVal[74], 29 ) ;   
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_FREEDIS, 	&g_Stv0288DefVal[103], 3 ) ; 
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_FREEVIT, 	&g_Stv0288DefVal[106], 3 ) ; 
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_TAGC1,	 	&g_Stv0288DefVal[109], 5 ) ;
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_TSTRM1, 	&g_Stv0288DefVal[114], 5 ) ;
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_TSTCK, 	&g_Stv0288DefVal[119], 5 ) ;
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_TSTNR2, 	&g_Stv0288DefVal[124], 1 ) ;
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_TSTDIS, 	&g_Stv0288DefVal[125], 2 ) ;
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_IOPSDAT, 	&g_Stv0288DefVal[127], 10 ) ;
	ErrorCode |=STV0288WrtReg ( bTunerIndex,R288_TCOMP1, 	&g_Stv0288DefVal[137], 3 ) ;
	ErrorCode |=STV0288STDBY (  bTunerIndex,0 );
	
	if (TS_SERIAL == g_nTSOutputMode[bTunerIndex])
	{
		g_Stv0288RegMapVal[R288_RS] = g_Stv0288RegMapVal[R288_RS]|0x40;	
	}
	else 
		g_Stv0288RegMapVal[R288_RS] =  g_Stv0288RegMapVal[R288_RS]&0xbf;	
	#ifdef 	CLOCK_HIGH2LOW
		g_Stv0288RegMapVal[R288_RS] =  g_Stv0288RegMapVal[R288_RS]|0x02;	
	#else
		g_Stv0288RegMapVal[R288_RS] =  g_Stv0288RegMapVal[R288_RS]&0xfd;	
	#endif
	bValue[0] = g_Stv0288RegMapVal[R288_RS];
	//CSTRACE(ERROR_LEVEL," [qpsk]g_nTSOutputMode=0x%x  \n",g_nTSOutputMode[bTunerIndex]);
	//CSTRACE(ERROR_LEVEL," [qpsk]stv0288 R288_RS=0x%x  \n",g_Stv0288RegMapVal[R288_RS]);
	ErrorCode |= STV0288WrtReg ( bTunerIndex, R288_RS, bValue, 1 );	
	STV0288GetMasterClock();////get master clock
	CSASSERT(ErrorCode == CSQPSK_SUCCESS);
	if(  ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
//	vDebug_Regisger_Value( bTunerIndex);
	//CSTRACE(ERROR_LEVEL," [qpsk]stv0288 reg init suceess \n");
	return CSQPSK_SUCCESS;
	
}
//carrier lock after timing lock
BOOL bSTV0288CheckCarrierLock ( CSHDITunerIndex bTunerIndex)
{
	BYTE bValue;
	int ErrorCode;
	int i;
	
	for(i=0;i<5;i++)
	{
		ErrorCode = STV0288RdReg ( bTunerIndex,R288_VSTATUS, &bValue, 1 ) ;
		if(ErrorCode != CSQPSK_SUCCESS)
			return 0;
		bValue &=CFOUND_FLAG;
		if(bValue )  //CF lock
			return 1;
		else 
			CSSleep(5);
	}
		//CSTRACE( ERROR_LEVEL, "carrier not OK!!\r\n");
		return 0;

}
//time recovery lock
BOOL bSTV0288CheckTimeLock ( CSHDITunerIndex bTunerIndex)
{
	BYTE bValue;
	int ErrorCode;
	
	int i;
	
	for(i=0;i<5;i++)
	{
		ErrorCode = STV0288RdReg ( bTunerIndex,R288_TLIRM, &bValue, 1 ) ;
		if(ErrorCode != CSQPSK_SUCCESS)
			return 0;
		bValue &=TIMING_FLAG;
		
		if(bValue )  //time lock
			return 1;
		else 
			CSSleep(5);
	}
		//CSTRACE( ERROR_LEVEL, "timing not OK!!\r\n");
		return 0;

}
BOOL bSTV0288CheckTPLock ( CSHDITunerIndex bTunerIndex)
{
	BYTE bValue=0;
	int ErrorCode;
	
	int i;
	
	for(i=0;i<5;i++)
	{
		ErrorCode = STV0288RdReg ( bTunerIndex,R288_VSTATUS, &bValue, 1 ) ;
		if(ErrorCode != CSQPSK_SUCCESS)
			return 0;
		
		bValue &=TPLOCK_FLAG;
		
		if(bValue )  //tp lock//sync word found
			return 1;
		else 
		{
			if (CSQPSK_DROPPED == CSQPSKSleep(bTunerIndex, 2))
			{
				return CSQPSK_DROPPED;
			}
		}
	}
	return 0;

}

CSQPSK_Error_t STV0288GetLockStatus ( CSHDITunerIndex bTunerIndex, int *pnLockStatus )
{
	BYTE bValue, bTemp;
	int nStatus = ALLLOST;
	int ErrorCode;
	int ii;
	
	CSASSERT( NULL != pnLockStatus);
	if( NULL == pnLockStatus) 
		return CSQPSK_FAILURE;
	*pnLockStatus = ALLLOST;
	for(ii=0; ii<5; ii++)
	{
		ErrorCode = STV0288RdReg ( bTunerIndex,R288_VSTATUS, &bValue, 1 ) ;
		//CSTRACE(ERROR_LEVEL,"[qpsk] R288_VSTATUS = 0x%x  \n" ,bValue);
		if ( ErrorCode != CSQPSK_SUCCESS )
		{
			continue;
		}
	
		bTemp = bValue & VSTATUS_MASK ;
	
		if ( bTemp == ( CFOUND_FLAG | TPLOCK_FLAG ) )
		{
			nStatus = TP_LOCK;
			break;
		}
		else if ( bTemp == CFOUND_FLAG )
		{
			nStatus = CFOUND;
			//break;
		}
		CSSleep(5);
	}

	*pnLockStatus = nStatus;

	return CSQPSK_SUCCESS;
}

CSQPSK_Error_t STV0288CheckLockStatus ( CSHDITunerIndex bTunerIndex, int *pnLockStatus )
{
	int nReturn;
	int nStatus;

	*pnLockStatus = FALSE;
	CSASSERT( NULL != pnLockStatus);
	if( NULL == pnLockStatus) 
		return CSQPSK_FAILURE;
#if 0
	nReturn = STV0288GetLockStatus (bTunerIndex, &nStatus);

	if ( nReturn == CSQPSK_SUCCESS )
	{
		if (TP_LOCK == nStatus)
12345

stv0288drv.c - 源码说明

本页面展示了「QPSK Tuner details, for conexant chipset.」中的 stv0288drv.c 源码文件，采用 C语言 编程语言编写，共 2,124 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫下载站收录了大量与conexant相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?