stv0299drv.c

QPSK Tuner details, for conexant chipset.

/* +==========================================================================+ */
/* | Function:	4r?*I2CM(5@													  |	*/		
/* | Return:	3I9&1jV>													  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299EnableTunerI2C ( CSHDITunerIndex bTunerIndex )
{
	BYTE bValue;

	//
	// [July 10, 2005]Modify by yuxibo in Istanbul.
	// STB6000 need some repeater response time, otherwise I2C errors
	// will occure.
	//
	//bValue = 0x85 ;
	bValue = 0xa5 ;
	return ( STV0299WriteReg ( bTunerIndex,STV0299REG_I2CRPT, &bValue, 1 ) );
}


/* +==========================================================================+ */
/* | Function:	9X1UI2CM(5@													  |	*/		
/* | Return:	3I9&1jV>													  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299DisableTunerI2C (CSHDITunerIndex bTunerIndex)
{
	return CSQPSK_SUCCESS ;
}

/* +==========================================================================+ */
/* | Function:	<l2bCHIP IDJG7qU}H7 ( SCSZLink ICWT6/J61p )					  |	*/		
/* | Input:		N^															  |	*/
/* | Output:	N^															  |	*/
/* | Return:	U}H7, 75;XSUCCESS, 7qTr75;XFAILURE							  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299CheckChipID ( CSHDITunerIndex bTunerIndex, BYTE bTSOutMode )
{
	BYTE bValue ;
	int ErrorCode;

	hSTV0299I2C[bTunerIndex] = 0;
	if (CSI2COpen(bTunerIndex,STV0299_ADDR,&hSTV0299I2C[bTunerIndex]) != CSI2C_SUCCESS)
	{
		CSTRACE( ERROR_LEVEL, "\n[HDI][CS_QPSK][STV0299CheckChipID]:\n******** STV0299 Open I2C Error ********");
     		return CSQPSK_I2C_ERROR;
	}  

	 ErrorCode = STV0299RdReg ( bTunerIndex,STV0299REG_ID, &bValue, 1 );
	if ( ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
	
	if ( bValue == STV0299_ID )
	{
		return CSQPSK_SUCCESS;
	}
	else 
	{
		CSI2CClose( hSTV0299I2C[bTunerIndex]);
		return CSQPSK_FAILURE;
	}
}

/* +==========================================================================+ */
/* | Function:	STV0299=xHk/MK3vJ!5gD#J=									  |	*/		
/* | Input:		Power Down D#J= ( 0: U}3#.  1: J!5g	)						  |	*/
/* | Output:	N^															  |	*/
/* | Return:	2YWw3I9&1jV>												  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299STDBY ( CSHDITunerIndex bTunerIndex, BYTE bPDownFlag )
{
	BYTE bValue ;

	bValue = bPDownFlag << 7;

	return ( STV0299WrtReg ( bTunerIndex,STV0299REG_MCR, &bValue, 1 ) );
}

/* +==========================================================================+ */
/* | Function:	IhVC Link IC 5D7{:EBJ<D4fFw									  |	*/		
/* | Input:		7{:EBJ(KbpsN*5%N;)											  |	*/
/* | Output:	N^															  |	*/
/* | Return:	2YWw3I9&1jV>												  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299SetSRate ( CSHDITunerIndex bTunerIndex, DWORD dwSymbolRate )
{
	DWORD dwSRate;
	BYTE bValue[4];
	int ErrorCode=0;
	/*
	dwSRate = dwSymbolRate / (fM_CLK / pow (2, 20))
	fM_CLK = 88M = 88000K
	==>
	dwSRate = dwSymbolRate * pow(2, 16) / 5500
	*/
	dwSRate = dwSymbolRate << 16;
	dwSRate /= 5500;
	
	bValue[0] = (BYTE)((dwSRate >> 12) & 0xff);
	bValue[1] = (BYTE)((dwSRate >> 4) & 0xff);
	bValue[2] = (BYTE)((dwSRate << 4) & 0xf0);

	if ( STV0299WrtReg ( bTunerIndex,STV0299REG_SFRH, bValue, 3 ) != CSQPSK_SUCCESS )
	{
		ErrorCode++;
	}	
	
	if ( ErrorCode != 0 )
	{
		return CSQPSK_FAILURE;
	}
	else
	{
		return CSQPSK_SUCCESS;
	}	

}

/* +==========================================================================+ */
/* | Function:	;qH!PE:EVJA?												  |	*/		
/* | Input:		N^															  |	*/
/* | Output:	N^															  |	*/
/* | Return:	PE:EVJA?0-255V.<d (J}V5T=4s, PE:EVJA?T=:C)					  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299SignalQuality(CSHDITunerIndex bTunerIndex, int *pnSignalQuality )
{
	BYTE bSNR[4];
	WORD wTmp;
	DWORD dwQPSK_EbNo;
	int nLockStatus;
	int ErrorCode;

	ErrorCode = STV0299GetLockStatus(bTunerIndex,&nLockStatus);
	if ( ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
	
	if (  nLockStatus!= TP_LOCK )
	{
		dwQPSK_EbNo = 0;
	}
	else
	{
		ErrorCode = STV0299RdReg ( bTunerIndex,STV0299REG_NIRM, bSNR, 2 );
		if ( ErrorCode != CSQPSK_SUCCESS )
			return ErrorCode;

		wTmp = bSNR[0];
		wTmp = ((wTmp<<8)&0xff00)|bSNR[1];
		
		dwQPSK_EbNo = wTmp;
		if( dwQPSK_EbNo > 0x3100)	// SPP'76N'Ih6(N*(0x1200 - 0x3000)
			dwQPSK_EbNo = 0x3100;
		if( dwQPSK_EbNo < 0x1600) 
			dwQPSK_EbNo = 0x1600;

		dwQPSK_EbNo = ( 0x3100 - dwQPSK_EbNo ) * 100 / (0x3100-0x1600);
	}
	*pnSignalQuality = dwQPSK_EbNo;
	return CSQPSK_SUCCESS;
}			  
/* +==========================================================================+ */
/* | Function:	;qH!PE:EG?6H ( 4}5wJT )										  |	*/		
/* | Input:		N^															  |	*/
/* | Output:	N^															  |	*/
/* | Return:	PE:EG?6H0-255V.<d (J}V5T=4s, PE:EG?6HT=4s)					  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299SignalStrength ( CSHDITunerIndex bTunerIndex, int *pnSignalStrength )
{
	BYTE bSPOWER;
	int nLevel;
	int ErrorCode;
	int nLockStatus;
/* del by th on 070103 for no need to check lock status 
	ErrorCode = STV0299GetLockStatus(bTunerIndex,&nLockStatus);
	if ( ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
	
	if (  nLockStatus!= TP_LOCK )
	{
		*pnSignalStrength = 0;
	}
	else*/
	{		
		ErrorCode = STV0299RdReg ( bTunerIndex, STV0299REG_AGC1I, &bSPOWER, 1 );
		if ( ErrorCode != CSQPSK_SUCCESS )
			return ErrorCode;

	
		if ( bSPOWER >= 0x80 )
		{
			nLevel = (255-bSPOWER)*(-1);
		}
		else
		{
			nLevel = bSPOWER;
		}
		

		if (nLevel > 90)
			nLevel = 90 ;

		*pnSignalStrength = 100*( nLevel + 128 ) / 218;
	}
		
	return CSQPSK_SUCCESS;
}



/* +==========================================================================+ */
/* | Function:  ;qH!PE:ENsBkBJ												  |	*/		
/* +==========================================================================+ */
CSQPSK_Error_t STV0299BER(CSHDITunerIndex bTunerIndex, DWORD *pdwBer)
{

	DWORD dwTotalBits[] =
	{
		0x8000 ,	// 2^12 * 2^3
		0x20000 ,	// 2^14 * 2^3
		0x80000,	// 2^16 * 2^3
		0x200000,	// 2^18 * 2^3
	};	

	BYTE pbBER[4], bERR;
	DWORD dwErrCNT, dwBaseCNT;
	DWORD dBER;
	int ErrorCode;
	int nLockStatus;
	
	ErrorCode = STV0299GetLockStatus(bTunerIndex,&nLockStatus);/*add by th for it is need to check lock status on 070103*/
	if ( ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
	
	if (nLockStatus != TP_LOCK )
	{
		*pdwBer = 10000000;
		return CSQPSK_SUCCESS;
	}
	
	ErrorCode = STV0299RdReg ( bTunerIndex, STV0299REG_ERRCNT, &bERR, 1 );
	if ( ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
	
	dwBaseCNT = dwTotalBits[(bERR & 0x03)] ;

	ErrorCode = STV0299RdReg ( bTunerIndex, STV0299REG_ERRCNT_HIGH, pbBER, 2 );
	if ( ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
	
	dwErrCNT = ( ((DWORD)pbBER[0]) << 8 ) + (DWORD)pbBER[1] ;

	/*
	 *	Modify by yuxibo 2005.11.22
	 */
	dBER = dwErrCNT * ( 10000000 / dwBaseCNT );
	
	*pdwBer = dBER;
	
	return CSQPSK_SUCCESS;
}

/* +==========================================================================+ */
/* | Function:  IhVCCARRIER FREQUENCY REGISTER											  |	*/		
/* | Input:		Derotator Frequency												  |	*/
/* | Output:	N^															  |	*/
/* | Return:	2YWw3I9&1jV>												  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t STV0299DerotFreq (CSHDITunerIndex bTunerIndex, DWORD dwDerotFrequency)
{
	BYTE bDerotFreq[4];
        BYTE bValue;

        STV0299RdReg ( bTunerIndex, 0x13, &bValue, 1 );
        bValue |= 0x80;
        STV0299WrtReg ( bTunerIndex, 0x13, &bValue, 1 );
	bDerotFreq[0] = (BYTE) ( ( dwDerotFrequency >> 8 ) & 0xff );
	bDerotFreq[1] = (BYTE) ( dwDerotFrequency & 0xff );
        
	return ( STV0299WrtReg ( bTunerIndex, STV0299REG_CFRM, bDerotFreq, 2 ) );
}			  

CSQPSK_Error_t STV0299GetDerotFreq (CSHDITunerIndex bTunerIndex, int *nDerotFrequency)
{
	BYTE bDerotFreq[4];
	DWORD dwDerotFrequency;
	int nDirect = 1;
	int ErrorCode;

	ErrorCode = STV0299RdReg ( bTunerIndex, STV0299REG_CFRM, bDerotFreq, 2 );
	if ( ErrorCode != CSQPSK_SUCCESS )
		return ErrorCode;
	
	dwDerotFrequency = ((DWORD)bDerotFreq[0] << 8 ) + (DWORD)bDerotFreq[1];
	if (dwDerotFrequency & 0x8000)
	{
		dwDerotFrequency = 0xFFFF - dwDerotFrequency;
		nDirect = -1;
	}
	dwDerotFrequency = (dwDerotFrequency * 1375 + 0x200) / 0x400;
        
	*nDerotFrequency = (int)dwDerotFrequency * nDirect;
	return CSQPSK_SUCCESS;
}

CSQPSK_Error_t STV0299SetDerotFrequency (CSHDITunerIndex bTunerIndex, int nFrequency)
{
	int dwDerotFrequency;
	int nDerotFrequency;

	if (nFrequency < 0)
	{
		nDerotFrequency = (-1) * nFrequency;
		dwDerotFrequency = nDerotFrequency * 0x400 / 1375;
		dwDerotFrequency = 0xFFFF - dwDerotFrequency;
	}
	else
	{
		dwDerotFrequency = nFrequency * 0x400 / 1375;
	}	
#if 1
	return STV0299DerotFreq(bTunerIndex, dwDerotFrequency);
#else
	return STV0299DerotFreq(bTunerIndex, 0);
#endif
}


/* +--------------------------------------------------------------------------+ */
/* +==========================================================================+ */
/* |						RTOB:/J}SkDiSEqCSP9X							  |	*/		
/* +==========================================================================+ */
/* +--------------------------------------------------------------------------+ */

/* +==========================================================================+ */
/* | Function:	=xHkDiSEqC W4L,												  |	*/		
/* +==========================================================================+ */
CSQPSK_Error_t CSDSCActive ( CSHDITunerIndex bTunerIndex )
{
	BYTE bValue[4];

	bValue[0] = 0 | DiSEqC_MODE | MODULATED_BURST;

	return ( STV0299WriteReg ( bTunerIndex, STV0299REG_DiSEqC, bValue, 1 ) );
}

/* +==========================================================================+ */
/* | Function:	7"KMTONE BURST C|An  										  |	*/		
/* | DiSEqC		bTBSwitch:													  |	*/
/* +==========================================================================+ */
static CSQPSK_Error_t CSDSCTBCommand ( CSHDITunerIndex bTunerIndex, BYTE bTBSwitch )
{
	BYTE bValue;
	int ErrorCode;

	bValue = 0;

	bValue &= ~( DiSEqCMODE_MASK | TONEBURST_MASK );

	if ( bTBSwitch == 0 )
	{
		bValue |= DiSEqC_MODE ;

		ErrorCode = STV0299WriteReg ( bTunerIndex, STV0299REG_DiSEqC, &bValue, 1 );
		if ( ErrorCode != CSQPSK_SUCCESS )
			return ErrorCode;
		
		bValue = 0x00;

		return STV0299WriteReg ( bTunerIndex, STV0299REG_DiSEqCFIFO, &bValue, 1 );		
	}
	else //if ( bTBSwitch == 1 )
	{
		bValue |= DiSEqC_MODE ;

		ErrorCode = STV0299WriteReg ( bTunerIndex, STV0299REG_DiSEqC, &bValue, 1 );
		if ( ErrorCode != CSQPSK_SUCCESS )
			return ErrorCode;

		bValue = 0xFF;

		return STV0299WriteReg ( bTunerIndex, STV0299REG_DiSEqCFIFO, &bValue, 1 );
	}
	
}

CSQPSK_Error_t CSToneBurstCommandOnly (CSHDITunerIndex bTunerIndex, BYTE bToneBurstSel)
{
	//sfg int nReturn = CSQPSK_SUCCESS;
	BYTE bValue;
	BYTE bPreF22KStatus;
	
	if (bToneBurstSel == 0)
		return CSQPSK_SUCCESS;
	
	if ( CSI2CRequestBus_inner(bTunerIndex, CSHDI_TIMEOUT_INFINITY) == CSI2C_SUCCESS )
	{
		STV0299WaitDiSEqCFree(bTunerIndex);
		if ( STV0299ReadReg ( bTunerIndex,STV0299REG_DiSEqC, &bValue, 1 ) != CSQPSK_SUCCESS )
		{
			CSI2CReleaseBus_inner(bTunerIndex);
			return CSQPSK_FAILURE;
		}

		bPreF22KStatus = bValue & DiSEqCMODE_MASK;	// 5C5=22KW4L,#,1cSZRT:s;V84!#

		if ( DiSEqCF22KSwitch ( bTunerIndex, CSHDI_OFF ) != CSQPSK_SUCCESS )			// 9X22KJd3v!#
		{
			CSI2CReleaseBus_inner(bTunerIndex);
			return CSQPSK_FAILURE;
		}
		CSSleep(25);
		
		if (CSDSCTBCommand(bTunerIndex, bToneBurstSel-1) != CSQPSK_SUCCESS)
		{
			CSI2CReleaseBus_inner(bTunerIndex);
			return CSQPSK_FAILURE;
		}

		STV0299WaitDiSEqCFree(bTunerIndex);
		CSSleep(40);
		if (STV0299WriteReg ( bTunerIndex, STV0299REG_DiSEqC, &bPreF22KStatus, 1 ) != CSQPSK_SUCCESS)
		{
			CSI2CReleaseBus_inner(bTunerIndex);
			return CSQPSK_FAILURE;
		}
		CSI2CReleaseBus_inner(bTunerIndex);
		return CSQPSK_SUCCESS;
	}
	else
		return CSQPSK_FAILURE;
}

int GetST0299CurPar( DWORD dwCurSymbolRate,DWORD* pdwSearchTime,DWORD* pdwFreqStep,DWORD* pdwWaitTime)
{
	int ii;
	int nCount=sizeof(g_ppdwSegSymbR)/(sizeof(DWORD)*PERROW);
	// sfg int nReturn=CSQPSK_FAILURE;
	
	//sttbx_Print("\ndwCurSymbolRate = %d", dwCurSymbolRate);
	for(ii=0;ii<nCount;ii++)
	{