ix2450drv.c

QPSK Tuner details, for conexant chipset.

/*************************************************************************

* IX2360DRV.C                                                           *

* Copyright ? Shenzhen Coship Electronics Co.#,LTD.  2002.3             *

* All rights reserved.                                                  *

*                                                                       *
 
* Author: Zhou Cheng                                                    *

* Date:  2002/3/13                                                      *

* Compiler:					                                            *

*                                                                       *

* Description:	PLL IC IX2360 Driver ( used in SHARP0184 Tuner )	    *

* Notes:                                                                *

* Update:   2002/3/6  Zhou Cheng										*

*************************************************************************/
// For 0184 Tuner
#include "CSQpskCFG.h"
#include "cs_typedef.h"
#include "CSHDI_typedef.h"
#include "cs_i2c.h"
#include "cs_os.h"
#include "IX2450DRV.h"
#include "cs_frnpublic.h"
#include "cs_assert.h"

#define TUNER_IF		0
#define TUNE_STEP		125
#define TUNELIMIT_LOW	900000		// KHz
#define TUNELIMIT_HIGH	2200000		// KHz
#define BANDFREQREF		1450000		// KHz
#define IX2450ADDR		0xc0
#define PLLLOCK_MASK	0x40
#define PLLLOCK_FLAG	0x40

static HCSHANDLE hIX2450I2C[MAX_TUNER_NUM];
//ADD BY SFG FOR COMPILER
extern CSQPSK_Error_t STV0299EnableTunerI2C ( CSHDITunerIndex bTunerIndex );
extern CSQPSK_Error_t STV0299DisableTunerI2C (CSHDITunerIndex bTunerIndex);
//add end
CSQPSK_Error_t IX2450Init(CSHDITunerIndex bTunerIndex)
{
	int ErrorCode;

	hIX2450I2C[bTunerIndex] = 0;
	ErrorCode = CSI2COpen(bTunerIndex,IX2450ADDR,&hIX2450I2C[bTunerIndex]);
	if (ErrorCode != CSI2C_SUCCESS)
	{
		return CSQPSK_I2C_ERROR;
	}
	return CSQPSK_SUCCESS;
}

CSQPSK_Error_t IX2450Term(CSHDITunerIndex bTunerIndex)
{
	int ErrorCode;
	ErrorCode = CSI2CClose(hIX2450I2C[bTunerIndex]);
	if (ErrorCode != CSI2C_SUCCESS)
	{
		return CSQPSK_I2C_ERROR;
	}
	return CSQPSK_SUCCESS;
}

/* +==========================================================================+ */
/* | Function:	IhVC TUNER 5wP3F5BJ											  |	*/		
/* | Input:																	  |	*/
/* | Output:	N^															  |	*/
/* | Return:	2YWw3I9&1jV>												  |	*/
/* +==========================================================================+ */
CSQPSK_Error_t IX2450WrtFreq( CSHDITunerIndex bTunerIndex,BYTE *pbTune ,DWORD dwDataLen)
{
	int ErrorCode;

	ErrorCode= CSI2CWriteWithStop ( hIX2450I2C[bTunerIndex], pbTune, dwDataLen ) ;
	if (ErrorCode != CSI2C_SUCCESS)
	{
		return CSQPSK_I2C_ERROR;
	}
	return CSQPSK_SUCCESS;

}

/* +==========================================================================+ */
/* | Function:	<l2b TUNER PLL W4L,											  |	*/		
/* | Input:		N^															  |	*/
/* | Output:	6A3v5DJ}>]													  |	*/
/* | Return:	0 -- PLL Lost Lock, 1 -- PLL Lock							  |	*/
/* +==========================================================================+ */

CSQPSK_Error_t IX2450GetPLLStatus ( CSHDITunerIndex bTunerIndex, int *pnPllLock )
{
	BYTE bValue;
	int ret;
	
	if ( CSI2CRequestBus_inner(bTunerIndex, CSHDI_TIMEOUT_INFINITY) == CSI2C_SUCCESS )
	{
		STV0299EnableTunerI2C(bTunerIndex);
		ret = CSI2CReadWithStop ( hIX2450I2C[bTunerIndex], &bValue, 1 ) ;
		STV0299DisableTunerI2C(bTunerIndex);
		CSI2CReleaseBus_inner(bTunerIndex);

		if (ret == CSI2C_SUCCESS)
		{
			if (( bValue & PLLLOCK_MASK ) == PLLLOCK_FLAG )
				*pnPllLock = 1;
			else
				*pnPllLock = 0;
			
			return CSQPSK_SUCCESS;
		}
	}

	return CSQPSK_I2C_ERROR;
}	
/*=======================================================================================*/
/*| BS2F7VZ0194 Tuner use																|*/
/*=======================================================================================*/
static void Calculate_VCO(DWORD dwFrequency, BYTE *pbTunerB)
{
	BYTE bDIVValue = 1; 
	BYTE bBAValue = 6;

	if ( dwFrequency < 970000 )
	{
		bDIVValue = 1 ;
		bBAValue = 6 ;
	}
	else if ( dwFrequency < 1065000 )
	{
		bDIVValue = 1 ;
		bBAValue = 6 ;
	}
	else if ( dwFrequency < 1170000 )
	{
		bDIVValue = 1 ;
		bBAValue = 7 ;
	}
	else if ( dwFrequency < 1300000 )
	{
		bDIVValue = 0 ;
		bBAValue = 1 ;
	}
	else if ( dwFrequency < 1445000 )
	{
		bDIVValue = 0 ;
		bBAValue = 2 ;
	}
	else if ( dwFrequency < 1607000 )
	{
		bDIVValue = 0 ;
		bBAValue = 3 ;
	}
	else if ( dwFrequency < 1778000 )
	{
		bDIVValue = 0 ;
		bBAValue = 4 ;
	}
	else if ( dwFrequency < 1942000 )
	{
		bDIVValue = 0 ;
		bBAValue = 5 ;
	}
	else if ( dwFrequency < 2131000 )
	{
		bDIVValue = 0 ;
		bBAValue = 6 ;
	}
	else
	{
		bDIVValue = 0 ;
		bBAValue = 6 ;
	}


	*(pbTunerB + 3) &= 0x1D ;
	*(pbTunerB + 3) |= (bBAValue<<5) | (bDIVValue<<1) ;
}

static void Calculate_PLL_LPF_Cutoff(DWORD dwBaudRate, BYTE *pbTunerB)
{
	// sfg for compier BYTE bPDValue ;
	
	*(pbTunerB + 2) &= 0xE5 ;
	*(pbTunerB + 3) &= 0xF3 ;

	if (dwBaudRate >= 39000)			// LPF cut-off Frequency = 30MHz
	{
		*(pbTunerB + 2) |= (0x02 << 3) ;
		*(pbTunerB + 3) |= (0x03 << 2) ;
	}
	else if (dwBaudRate >= 35000)		// LPF cut-off Frequency = 28MHz
	{
		*(pbTunerB + 3) |= (0x03 << 2) ;
	}
	else if (dwBaudRate >= 30000)		// LPF cut-off Frequency = 26MHz
	{
		*(pbTunerB + 2) |= (0x03 << 3) ;
		*(pbTunerB + 3) |= (0x01 << 2) ;
	}
	else if (dwBaudRate >= 26000)		// LPF cut-off Frequency = 24MHz
	{
		*(pbTunerB + 2) |= (0x01 << 3) ;
		*(pbTunerB + 3) |= (0x01 << 2) ;
	}
	else if (dwBaudRate >= 23000)		// LPF cut-off Frequency = 22MHz
	{
		*(pbTunerB + 2) |= (0x02 << 3) ;
		*(pbTunerB + 3) |= (0x01 << 2) ;
	}
	else if (dwBaudRate >= 21000)		// LPF cut-off Frequency = 20MHz
	{
		*(pbTunerB + 2) |= (0x00 << 3) ;
		*(pbTunerB + 3) |= (0x01 << 2) ;
	}
	else if (dwBaudRate >= 19000)		// LPF cut-off Frequency = 18MHz
	{
		*(pbTunerB + 2) |= (0x03 << 3) ;
		*(pbTunerB + 3) |= (0x02 << 2) ;
	}
	else if (dwBaudRate >= 18000)		// LPF cut-off Frequency = 16MHz
	{
		*(pbTunerB + 2) |= (0x01 << 3) ;
		*(pbTunerB + 3) |= (0x02 << 2) ;
	}
	else if (dwBaudRate >= 17000)		// LPF cut-off Frequency = 14MHz
	{
		*(pbTunerB + 2) |= (0x02 << 3) ;
		*(pbTunerB + 3) |= (0x02 << 2) ;
	}
	else if (dwBaudRate >= 16000)		// LPF cut-off Frequency = 12MHz
	{
		*(pbTunerB + 2) |= (0x00 << 3) ;
		*(pbTunerB + 3) |= (0x02 << 2) ;
	}
	else								// LPF cut-off Frequency = 10MHz
	{
		*(pbTunerB + 2) |= (0x03 << 3) ;
		*(pbTunerB + 3) |= (0x00 << 2) ;
	}
}

static void Calculate_DIV ( DWORD dwFrequency, DWORD dwTunerStep, DWORD dwIFFreq, BYTE *pbTunerB ) 
{
	DWORD dwTunerTemp ;

	dwTunerTemp = ((dwFrequency + dwIFFreq) + dwTunerStep / 2) / dwTunerStep;
	*(pbTunerB + 0) = (dwTunerTemp >> 8) & 0x7f ;
	*(pbTunerB + 1) = dwTunerTemp & 0xff ;
}


 CSQPSK_Error_t VZ0194SetFrequency( CSHDITunerIndex bTunerIndex, DWORD dwTunerFrequency, DWORD dwSymbolRate )
{
	DWORD TunerStep = (DWORD)500L ;
	BYTE pbTunerB[4], bByte4, bByte5;
	//sfg for compiler BYTE bTunerStatus;

	pbTunerB[2] = 0xE5 ;
	pbTunerB[3] = 0x00 ;
	Calculate_VCO (dwTunerFrequency, pbTunerB) ;
	Calculate_PLL_LPF_Cutoff(dwSymbolRate, pbTunerB) ;
	Calculate_DIV ( dwTunerFrequency, TunerStep, 0, pbTunerB );
	bByte4 = pbTunerB[2];
	bByte5 = pbTunerB[3];
	pbTunerB[2] &= 0xE3;
	pbTunerB[3] &= 0xF3;
	if ( CSI2CRequestBus_inner(bTunerIndex, CSHDI_TIMEOUT_INFINITY) == CSI2C_SUCCESS )
	{
        	if ( STV0299EnableTunerI2C (bTunerIndex) != CSQPSK_SUCCESS )
        	{
        	        CSI2CReleaseBus_inner(bTunerIndex);
        		CSTRACE( ERROR_LEVEL, "[HDIQPSK] Err enable tuner i2c  failed\n");
			CSTRACE( ERROR_LEVEL, "Position:file = %s,line = %s\n", __FILE__, __LINE__);
        		return CSQPSK_FAILURE;	// Enable TunerI2C
        	}
		CSSleep ( 1 );
        	IX2450WrtFreq ( bTunerIndex, pbTunerB, 4 ) ;
	        STV0299DisableTunerI2C(bTunerIndex);
       	 CSI2CReleaseBus_inner(bTunerIndex);
	}
	CSSleep ( 10 );
	
	pbTunerB[2] |= 0x04;
	if ( CSI2CRequestBus_inner(bTunerIndex, CSHDI_TIMEOUT_INFINITY) == CSI2C_SUCCESS )
	{
        	if ( STV0299EnableTunerI2C (bTunerIndex) != CSQPSK_SUCCESS )
        	{
        	        CSI2CReleaseBus_inner(bTunerIndex);
        		CSTRACE( ERROR_LEVEL, "\n[HDI][CS_QPSK][FTDGetTunerStatus]:\nEnable Tuner I2c Fail");
        		return CSQPSK_FAILURE;	// Enable TunerI2C
        	}
	CSSleep ( 1 );
        	IX2450WrtFreq ( bTunerIndex, pbTunerB, 4 ) ;
//       	IX2450WrtFreq ( &pbTunerB[2], 2 ) ;
	        STV0299DisableTunerI2C(bTunerIndex);
       	        CSI2CReleaseBus_inner(bTunerIndex);
	}
	CSSleep ( 20 );
	
	pbTunerB[2] = bByte4;
	pbTunerB[3] = bByte5;

	if ( CSI2CRequestBus_inner(bTunerIndex, CSHDI_TIMEOUT_INFINITY) == CSI2C_SUCCESS )
	{
        	if ( STV0299EnableTunerI2C (bTunerIndex) != CSQPSK_SUCCESS )
        	{
        	        CSI2CReleaseBus_inner(bTunerIndex);
        		CSTRACE( ERROR_LEVEL, "\n[HDI][CS_QPSK][FTDGetTunerStatus]:\nEnable Tuner I2c Fail");
        		return CSQPSK_FAILURE;	// Enable TunerI2C
        	}
	CSSleep ( 1 );
         	IX2450WrtFreq ( bTunerIndex, pbTunerB, 4 ) ;
  //     	IX2450WrtFreq ( &pbTunerB[2], 2 ) ;
	        STV0299DisableTunerI2C(bTunerIndex);
       	        CSI2CReleaseBus_inner(bTunerIndex);
	}
	CSSleep ( 40 );
	return CSQPSK_SUCCESS ;
}