qpskfrontend.c

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

		
		g_bLinkICType[bTunerIndex] = CT202A;	

		g_QPSKDes[bTunerIndex].m_nType = 1;
		g_QPSKDes[bTunerIndex].m_pFunCheckLockStatus =  CT202ACheckLockStatus; 
		g_QPSKDes[bTunerIndex].m_pFunGetSignalBER = CT202AGetSignalBer;
		g_QPSKDes[bTunerIndex].m_pFunGetSignalquality = CT202AGetQuality;
		g_QPSKDes[bTunerIndex].m_pFunGetSignalStrength = CT202AGetStrength;
		g_QPSKDes[bTunerIndex].m_pFunSet22KSwitch = CT202AF22KSwitch ;
		g_QPSKDes[bTunerIndex].m_pFunSearchingSignal = CT202ALockChannel;
		g_QPSKDes[bTunerIndex].m_pFunSetStandby = CT202ASetStandby;
		g_QPSKDes[bTunerIndex].m_pFunSetClockPolarity= CT202ASetClockPolarity;
		g_pSTSChannelScan = CT202STS;
		g_GetSTSProc =  CT202GetSTSPercent;
		
		CSTRACE( INFO_LEVEL, "\n[HDI][CS_QPSK][CSQPSKInterInitialize over]: Link IC is CT202A!!!!! \n\r");
	}
else
#endif

	{
		g_bLinkICType[bTunerIndex] = 0xff;
		g_QPSKDes[bTunerIndex].m_nType = 0;
		g_QPSKDes[bTunerIndex].m_pFunCheckLockStatus = NULL;
		g_QPSKDes[bTunerIndex].m_pFunGetSignalBER = NULL;
		g_QPSKDes[bTunerIndex].m_pFunGetSignalquality = NULL;
		g_QPSKDes[bTunerIndex].m_pFunGetSignalStrength = NULL;
		g_QPSKDes[bTunerIndex].m_pFunSet22KSwitch = NULL;
		g_QPSKDes[bTunerIndex].m_pFunSearchingSignal = NULL;       
		g_QPSKDes[bTunerIndex].m_pFunSetStandby = NULL;
		g_QPSKDes[bTunerIndex].m_pFunSetClockPolarity= NULL;
		CSTRACE( WARN_LEVEL, "\n[HDI][CS_QPSK][CSQPSKInterInitialize]:\nLink IC is Unknown\n");
		return CSQPSK_DEVICE_UNKNOWN;
	}

        FTDDiSEqCInit(bTunerIndex);
	return CSQPSK_SUCCESS;

}

CSQPSK_Error_t CSQPSKSearchingSignal  ( CSHDITunerIndex bTunerIndex, CSQPSKCHANNEL *pCSCHANNEL )
{	
	int nReturn;
        if ( g_QPSKDes[bTunerIndex].m_nType )
        {
        	//[Jul 20, 2005] Added by Jacky
        	g_nFrequencyOffset[bTunerIndex] = pCSCHANNEL->m_nFrequencyOffset;
        	nReturn = g_QPSKDes[bTunerIndex].m_pFunSearchingSignal(bTunerIndex, pCSCHANNEL);
            	if ( nReturn == CSQPSK_SUCCESS )
            	{
			g_nFrequencyOffset[bTunerIndex] = pCSCHANNEL->m_nFrequencyOffset;			
		}

		return nReturn;  
        }
        else
        {
        	//CSTRACE( WARN_LEVEL, "\nSignal Dropped here\n");
                return CSQPSK_DROPPED;
        }
}

CSQPSK_Error_t CSQPSKSetStandby( CSHDITunerIndex bTunerIndex, int nStandby )
{
	 if ( g_QPSKDes[bTunerIndex].m_nType )
	 {
            	return g_QPSKDes[bTunerIndex].m_pFunSetStandby(bTunerIndex, nStandby);
	 }
	 return CSQPSK_DROPPED;
}

CSQPSK_Error_t CSQPSKSetClockPolarity( CSHDITunerIndex bTunerIndex, T_ClockPolarity clockPol )
{
	if( bTunerIndex < 0 || bTunerIndex >= MAX_I2C_NUM)
	{
#ifdef QPSK_DEBUG
		CSTRACE( ERROR_LEVEL, "[HDIQPSK] Err bTunerIndex = %d incorrect \n", bTunerIndex);
		CSTRACE( ERROR_LEVEL, "Position:file = %s,line = %d\n", __FILE__, __LINE__);
#endif
		return CSQPSK_FAILURE;
	}
	CSASSERT( g_bQPSKHasInitialized[bTunerIndex] == TRUE);
	if ( g_QPSKDes[bTunerIndex].m_nType )
	 {
            	return g_QPSKDes[bTunerIndex].m_pFunSetClockPolarity(bTunerIndex, clockPol);
	 }
	 else
                return CSQPSK_DROPPED;
}

void CSQPSKFEQuitSearching (CSHDITunerIndex bTunerIndex, int flag)
{
	g_nQuickExitFlag[bTunerIndex] = flag;
}

CSQPSK_Error_t CSQPSKGetSignalStrength ( CSHDITunerIndex bTunerIndex, int *pnSignalStrength )
{	
        if ( g_QPSKDes[bTunerIndex].m_nType )
            	return g_QPSKDes[bTunerIndex].m_pFunGetSignalStrength(bTunerIndex, pnSignalStrength);
        else
                return CSQPSK_DROPPED;
}

int CSGetFrequencyOffset ( CSHDITunerIndex bTunerIndex )
{
	return g_nFrequencyOffset[bTunerIndex] ;
}

CSQPSK_Error_t CSQPSKGetSignalQuality ( CSHDITunerIndex bTunerIndex, int *pnSignalQuality )
{        
        if ( g_QPSKDes[bTunerIndex].m_nType )
            	return g_QPSKDes[bTunerIndex].m_pFunGetSignalquality(bTunerIndex, pnSignalQuality);
        else
                return CSQPSK_DROPPED;
}

CSQPSK_Error_t CSQPSKGetCheckLockStatus ( CSHDITunerIndex bTunerIndex, int *pnLockStatus )
{	
        if ( g_QPSKDes[bTunerIndex].m_nType )
            	return g_QPSKDes[bTunerIndex].m_pFunCheckLockStatus(bTunerIndex, pnLockStatus);
        else
                return CSQPSK_DROPPED;
}

CSQPSK_Error_t CSQPSKSignalBER (CSHDITunerIndex bTunerIndex, DWORD *pdwBer)
{
        if ( g_QPSKDes[bTunerIndex].m_nType )
            	return g_QPSKDes[bTunerIndex].m_pFunGetSignalBER(bTunerIndex,pdwBer);
        else
                return CSQPSK_DROPPED;
}

CSQPSK_Error_t CSConfigResetPin ( CSHDITunerIndex bTunerIndex, BYTE bGPIOIndex )
{
	g_bResetGPIOIndex[bTunerIndex] = bGPIOIndex;

	if ( bGPIOIndex == CSHDI_GPIO_NO_USE )
	{
		return CSQPSK_SUCCESS;
	}	
	else if ( CSGPIOOpen(g_bResetGPIOIndex[bTunerIndex], CS_GPIO_OUPUT) != CS_GPIO_SUCCESS )
	{
		return CSQPSK_GPIO_ERROR;
	}

	return CSQPSKReset(bTunerIndex);	
}

CSQPSK_Error_t CSConfigLNBPowerPin ( CSHDITunerIndex bTunerIndex, BYTE bGPIOIndex )
{
	g_bLNBPowerGPIOIndex[bTunerIndex] = bGPIOIndex;

	if ( bGPIOIndex == CSHDI_GPIO_NO_USE )
	{
		return CSQPSK_SUCCESS;
	}	
	else if ( CSGPIOOpen(g_bLNBPowerGPIOIndex[bTunerIndex], CS_GPIO_OUPUT) != CS_GPIO_SUCCESS )
	{
		return CSQPSK_GPIO_ERROR;
	}

	return CSQPSK_SUCCESS;
}

CSQPSK_Error_t CSConfig13_18VPin ( CSHDITunerIndex bTunerIndex, BYTE bGPIOIndex )
{
	g_b13_18VGPIOIndex[bTunerIndex] = bGPIOIndex;

	if ( bGPIOIndex == CSHDI_GPIO_NO_USE )
	{
		return CSQPSK_SUCCESS;
	}	
	else if ( CSGPIOOpen(g_b13_18VGPIOIndex[bTunerIndex], CS_GPIO_OUPUT) != CS_GPIO_SUCCESS )
	{
		return CSQPSK_GPIO_ERROR;
	}
	
	return CSQPSK_SUCCESS;
}

CSQPSK_Error_t CSConfig0_12VPin ( CSHDITunerIndex bTunerIndex, BYTE bGPIOIndex )
{	
	g_b0_12VGPIOIndex[bTunerIndex] = bGPIOIndex;

	if ( bGPIOIndex == CSHDI_GPIO_NO_USE )
	{
		return CSQPSK_SUCCESS;
	}
	else if ( CSGPIOOpen(g_b0_12VGPIOIndex[bTunerIndex], CS_GPIO_OUPUT) != CS_GPIO_SUCCESS )
	{
		return  CSQPSK_GPIO_ERROR;
	}
	return CSQPSK_SUCCESS;
}


void CSSetConfigASIInSelect ( CSHDITunerIndex bTunerIndex, int nASIInSel, int nASIStatusPin ) 
{
#ifdef  STV0299_SUPPORT
	CSSetConfigASIInSel(bTunerIndex,nASIInSel, nASIStatusPin) ;
#endif
	return;
}


CSQPSK_Error_t CSQPSKReset ( CSHDITunerIndex bTunerIndex )
{
	int ErrorCode = CS_GPIO_SUCCESS;

	if ( g_bResetGPIOIndex[bTunerIndex] == 0xff )
	{
		return CSQPSK_FAILURE;
	}
	
	ErrorCode |= CSGPIOWrite(g_bResetGPIOIndex[bTunerIndex], 1);
	CSSleep(50);
	ErrorCode |= CSGPIOWrite(g_bResetGPIOIndex[bTunerIndex], 0);
	CSSleep(300);
	ErrorCode |= CSGPIOWrite(g_bResetGPIOIndex[bTunerIndex], 1);
	CSSleep(50);

	if ( ErrorCode != CS_GPIO_SUCCESS )
	{
		return CSQPSK_GPIO_ERROR;
	}

	return CSQPSK_SUCCESS;
}

CSQPSK_Error_t CS22KSwitch ( CSHDITunerIndex bTunerIndex, CSHDISwitch n22KStatus )
{	
        if ( g_QPSKDes[bTunerIndex].m_nType )
        {
			//g_TQPSKChannelCopy[bTunerIndex].b22K = n22KStatus;
			g_TQPSKChannelCopy1[bTunerIndex].b22K = n22KStatus;
			return g_QPSKDes[bTunerIndex].m_pFunSet22KSwitch(bTunerIndex, n22KStatus);
        }
        else
        {
                return CSQPSK_DROPPED;  
        }
}

void CSClear( CSHDITunerIndex bTunerIndex )
{
    	int returnCode = CS_OSP_SUCCESS;

	do
	{
		returnCode = CSWaitForSemaphore(g_hQPSKSemaphore[bTunerIndex], CSHDI_TIMEOUT_IMMEDIATE );	
	} while (returnCode == CS_OSP_SUCCESS);

}
void CSQPSKStopLock( CSHDITunerIndex bTunerIndex )
{
    	int returnCode = CS_OSP_SUCCESS;

	returnCode = CSReleaseSemaphore(g_hQPSKSemaphore[bTunerIndex], 1);
}

CSQPSK_Error_t CSQPSKSleep(CSHDITunerIndex bTunerIndex,DWORD dwSleepTime)
{
	DWORD dwTimes, ii;
	int nReturn ;
	
	dwTimes = (dwSleepTime + 9) / 10;
	for(ii=0; ii<dwTimes; ii++)
	{
		nReturn = CSWaitForSemaphore(g_hQPSKSemaphore[bTunerIndex], 10 );
		if ( nReturn == CS_OSP_SUCCESS)
		{
			CSReleaseSemaphore(g_hQPSKSemaphore[bTunerIndex], 1);
			//CSTRACE( WARN_LEVEL, "[CSQPSKSleep]Singal Dropped!!!!\n");
			return CSQPSK_DROPPED;
		}
	}
	return CSQPSK_SUCCESS;
}