tun0299.c

Zoran V966 DVD 解码 Soc芯片的源程序

/* **************************************************************************************
 *  Copyright (c) 2004 ZORAN Corporation, All Rights Reserved
 *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
 *
 *  File: $Workfile: .c $             
 *
 * Description:
 * ============
 * 
 * 
 * Log:
 * ====
 * $Revision: $
 * Last Modified by $Author:  $ at $Modtime: $ 
 **************************************************************************************** */
#include "Config.h"		// Global Configuration - do not remove!

#ifdef FTA_SUPPORT

#ifdef SATELLITE_299

#include "Include\SysDefs.h"
#include "Devices\i2c\i2c.h"
#include "Devices\demodulator\0299\def.h"
#include "Devices\demodulator\0299\tun0299.h"
#include "Devices\demodulator\0299\reg0299.h"
#include "Devices\demodulator\0299\0229.h"

static TUNER_PROP Tuner;	/*	Current tuner	*/

/*****************************************************
**FUNCTION	::	TunerGetProperties
**ACTION	::	Get the properties of the tuner
**PARAMS IN	::	NONE
**PARAMS OUT::	tnr	==> tuner properties   
**RETURN	::	NONE
*****************************************************/
void TunerGetProperties(TUNER_PROP *tnr)
{
	INT i;
	
	if(tnr != NULL)
	{
		tnr->Type = Tuner.Type;
		tnr->Address =	Tuner.Address;
		tnr->PLL =	Tuner.PLL; 
		tnr->Error = Tuner.Error;

		tnr->I_Q = Tuner.I_Q;
		tnr->FreqFactor = Tuner.FreqFactor;
		tnr->StepSize = Tuner.StepSize;
		tnr->IF = Tuner.IF;
		tnr->Repeator = Tuner.Repeator;
	
		tnr->SelectBW = Tuner.SelectBW; 
		i=0;
		while(i<(TUN_MAX_BW+1))
		{
			tnr->BandWidth[i] = Tuner.BandWidth[i];
			i++;
		}
	
		tnr->WrSize = Tuner.WrSize;
	
		for(i=0;i<Tuner.WrSize;i++)
			tnr->WrBuffer[i] = Tuner.WrBuffer[i];

		tnr->RdSize = Tuner.RdSize;
	
		for(i=0;i<Tuner.RdSize;i++)
			tnr->RdBuffer[i] = Tuner.RdBuffer[i];
	}
}

/*****************************************************
**FUNCTION	::	TunerResetError
**ACTION	::	reset the error state of the tuner 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerResetError(void)
{
	Tuner.Error = TNR_NO_ERR;
}

/*****************************************************
**FUNCTION	::	TunerInit
**ACTION	::	Initialize the tuner according to its type
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerInit(DEMOD_HANDLE handle)
{
	if (!Tuner.Error)
	{
		Tuner.SelectBW = 0;
		Tuner.BandWidth[TUN_MAX_BW] = 0L;	/* To avoid list without end	*/ 
	
		switch (Tuner.Type)
		{
			case TNR_VG6821:
				Tuner.PLL	=	PLL_5522; 
			
				Tuner.I_Q = -1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 125000L;
				Tuner.IF = 479500L;
				Tuner.BandWidth[0] = 36000L;
				Tuner.BandWidth[1] = 0L;
				Tuner.Repeator = 0;
			
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x0B;
				Tuner.WrBuffer[1] = 0x00;
				Tuner.WrBuffer[2] = 0xCE;
				Tuner.WrBuffer[3] = 0xA1;
			
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
				break;
		
			case TNR_VG1011:
				Tuner.PLL	=	PLL_5655; 
			
				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 125000L;
				Tuner.IF = 479500L;
				Tuner.BandWidth[0] = 36000L;
				Tuner.BandWidth[1] = 0L;
				Tuner.Repeator = 0;
			
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x34;
				Tuner.WrBuffer[1] = 0x7C;
				Tuner.WrBuffer[2] = 0x95;
				Tuner.WrBuffer[3] = 0x80;
			
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
				break;
		
			case TNR_EVALMAX:
				Tuner.PLL	=	PLL_5655; 
			
				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 500000L;
				Tuner.IF = 0L;
				Tuner.BandWidth[0] = 16000L;
				Tuner.BandWidth[1] = 60000L;
				Tuner.BandWidth[2] = 0L;
				Tuner.Repeator = 0;
			
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x08;
				Tuner.WrBuffer[1] = 0xC2;
				Tuner.WrBuffer[2] = 0x82;
				Tuner.WrBuffer[3] = 0x41;
			
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
				break;
		
			case TNR_TUA6100:	
				Tuner.PLL	=	PLL_TUA6100; 
			
				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 125000L;
				Tuner.IF = 0L;
				Tuner.BandWidth[0] = 60000L;
				Tuner.BandWidth[1] = 0L;
				Tuner.Repeator = 1;
				
				Tuner.WrSize = 2;
				Tuner.WrBuffer[0] = 0x00;	/* init register 0 */
				Tuner.WrBuffer[1] = 0x0B;   
				TunerReadWrite(handle, TRUE);
				
				Tuner.WrSize = 3;
				Tuner.WrBuffer[0] = 0x02;	/* init register 2 */
				Tuner.WrBuffer[1] = 0x1C;    
				Tuner.WrBuffer[2] = 0x20; 
				TunerReadWrite(handle,TRUE);
				
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x01;	/* default settings register 1 */
				Tuner.WrBuffer[1] = 0x2C;   
				Tuner.WrBuffer[2] = 0x96;
				Tuner.WrBuffer[3] = 0x00;
				
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
				break;
			
			case TNR_CUSTOM:
				Tuner.PLL	=	PLL_5659; 
			
				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 250000L;
				Tuner.IF = 0L;
				Tuner.BandWidth[0] = 36000L;
				Tuner.BandWidth[1] = 0L;
				Tuner.Repeator = 1;
			
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x18;
				Tuner.WrBuffer[1] = 0x38;
				Tuner.WrBuffer[2] = 0x83;
				Tuner.WrBuffer[3] = 0x00;
			
				Tuner.RdSize = 1;
				break;
		
			default:
				Tuner.Error = TNR_TYPE_ERR;
				break;
		}
	
		TunerReadWrite(handle, TRUE);
		TunerReadWrite(handle, FALSE);
	}
}


/*****************************************************
**FUNCTION	::	TunerSelect
**ACTION	::	Select the type of tuner used
**PARAMS IN	::	type	==> type of the tuner
**				address	==> I2C address of the tuner
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerSelect(DEMOD_HANDLE handle, TUNER_TYPE type,unsigned char address)
{
	TunerResetError();
	Tuner.Type = type;
	Tuner.Address = address;
	TunerInit(handle);
}

/*****************************************************
**FUNCTION	::	TunerSelectBandwidth
**ACTION	::	Select the bandwidth of the tuner (if this one not exist,
**				closest value bigger than bandwidth will be selected)
**PARAMS IN	::	bandwidth	==> bandwidth of the tuner 
**PARAMS OUT::	NONE  
**RETURN	::	Selected bandwidth, 0 if error
*****************************************************/
long TunerSelectBandwidth(long bandwidth)
{
	UINT16 band = 0;
	
	Tuner.SelectBW = 0;
	
	if (!Tuner.Error)
	{
		while(	(Tuner.BandWidth[Tuner.SelectBW + 1] != 0) && 
				(bandwidth > Tuner.BandWidth[Tuner.SelectBW]))
		{
			Tuner.SelectBW++;
		}
	
		switch(Tuner.Type)
		{
			case TNR_EVALMAX:
				switch(Tuner.SelectBW)
				{
					case 0:
						band = 0x00;	/* Wide bandwidth 16MHz */
					break;
					
					case 1:
						band = 0x01;	/* Narrow bandwidth 60MHz */   
					break;
				}
				Tuner.WrBuffer[3] =  (Tuner.WrBuffer[3] & 0xFE) | band; 

				break;
		
			default:
				break;
		}
		
		return Tuner.BandWidth[Tuner.SelectBW];  
	}
	
	return 0;
}


/*****************************************************
**FUNCTION	::	TunerSetNbSteps
**ACTION	::	Set the number of steps of the tuner
**PARAMS IN	::	nbsteps ==> number of steps of the tuner
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerSetNbSteps(DEMOD_HANDLE handle, UINT32 nbsteps)
{
	UINT32 Ncnt,Acnt,Prescaler;
	long freq;

	if (!Tuner.Error)
	{
		switch (Tuner.PLL)
		{
			case PLL_CUSTOM:
				Tuner.WrBuffer[2] = (unsigned char)((nbsteps & 0x00001F80)>>7);
				Tuner.WrBuffer[3] = (unsigned char)((nbsteps & 0x0000007F)<<1) | 1;
				break;

			case PLL_5522:
			case PLL_5655:
				Tuner.WrBuffer[0]= (unsigned char)((nbsteps & 0x00007F00)>>8);
				Tuner.WrBuffer[1]= (unsigned char)(nbsteps & 0x000000FF);
				break;

			case PLL_5659:
				Tuner.WrBuffer[0]= (unsigned char)((nbsteps & 0x00007F00)>>8);
				Tuner.WrBuffer[1]= (unsigned char)(nbsteps & 0x000000FF );
				Tuner.WrBuffer[2]= (unsigned char)((((long)Tuner.WrBuffer[2]) & 0x9F)|((nbsteps>>10) & 0x60));
				break;
			
			case PLL_TUA6100:
				Prescaler = (Tuner.WrBuffer[1] & 0x40) ? 64 : 32;	/* Prescaler = 64 if high 32 if low */
				Ncnt = nbsteps / Prescaler;							/* N counter = nbsteps / Prescaler	*/
				Acnt = nbsteps - (Ncnt * Prescaler);				/* A counter = nbsteps - N counter * Prescaler	*/
				
				Tuner.WrBuffer[1]= Tuner.WrBuffer[1]|((unsigned char)((Ncnt & 0x600)>>9));
				Tuner.WrBuffer[2]= (unsigned char)((Ncnt & 0x1FE)>>1);
				Tuner.WrBuffer[3]= (unsigned char)(((Ncnt & 0x01)<<7)|(Acnt & 0x7F));
				
				freq = TunerGetFrequency();
				
				Tuner.WrBuffer[1] = (Tuner.WrBuffer[1] & 0x7F) | ((freq>1525000L) ? 0x80 : 0x00); /* VCO switching */ 
				Tuner.WrBuffer[1] = (Tuner.WrBuffer[1] & 0xCF) | ((freq>1430000L) ? 0x00 : 0x20); /* N-counter value switching */  
				break;

			default:
				Tuner.Error = TNR_PLL_ERR;
				break;
		}

		TunerReadWrite(handle, TRUE);         
	}
}


/*****************************************************
**FUNCTION	::	TunerGetNbSteps
**ACTION	::	Get the number of steps of the tuner
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	Number of steps, 0 if an error occur
*****************************************************/
UINT32 TunerGetNbSteps(void)
{
	UINT32 nbsteps = 0;
	UINT32 Ncnt, Acnt, Prescaler;

	if (!Tuner.Error)
	{
		switch (Tuner.PLL)
		{
			case PLL_5522:
			case PLL_5655:
				nbsteps	= (UINT32)((Tuner.WrBuffer[0] & 0x007F)<<8);
				nbsteps	|= (UINT32)Tuner.WrBuffer[1] & 0x000000FF;
				break;

			case PLL_5659:
				nbsteps	 = (UINT32)((Tuner.WrBuffer[0] & 0x007F)<<8);
				nbsteps	|= ((UINT32)Tuner.WrBuffer[1] & 0x000000FF);
				nbsteps	|= (UINT32)((Tuner.WrBuffer[2] & 0x0060)<<10);
				break;
			
			case PLL_TUA6100:
				Prescaler = (Tuner.WrBuffer[1] & 0x40) ? 64 : 32;	/* Prescaler = 64 if high 32 if low */
				Ncnt =	((Tuner.WrBuffer[1] & 0x03)<<9)|
						((Tuner.WrBuffer[2] & 0xFF)<<1)|
						((Tuner.WrBuffer[3] & 0x80)>>7);	/* N counter value */
				Acnt = (Tuner.WrBuffer[3] & 0x7F);			/* A counter value */
				nbsteps = (Prescaler * Ncnt) + Acnt; 
				break;

			case PLL_CUSTOM:
				nbsteps	= ((Tuner.WrBuffer[2] & 0x003F)<<7);
				nbsteps	|= ((Tuner.WrBuffer[3] & 0x00FE) >> 1);
				break;

			default:
				Tuner.Error = TNR_PLL_ERR;
				break;
		}
	}
	
	return nbsteps;
}


/*****************************************************
**FUNCTION	::	TunerGetFrequency
**ACTION	::	Get the frequency of the tuner
**PARAMS IN	::	NONE  
**PARAMS OUT::	NONE  
**RETURN	::	frequency of the tuner (KHz), 0 if an error occur 
*****************************************************/
long TunerGetFrequency(void)
{
	long frequency = 0;
	
	if (!Tuner.Error)
	{
		if (Tuner.StepSize>0)
		{
			frequency = ((TunerGetNbSteps()*(Tuner.StepSize/2)) - 500*Tuner.IF)/500	;
			frequency *= Tuner.FreqFactor;
		}
		else
		{
			Tuner.Error = TNR_STEP_ERR;
		}
	}
	return frequency; 
}


/*****************************************************
**FUNCTION	::	TunerSetFrequency
**ACTION	::	Set the frequency of the tuner
**PARAMS IN	::	frequency ==> the frequency of the tuner (KHz) 
**PARAMS OUT::	NONE  
**RETURN	::	real tuner frequency, 0 if an error occur 
*****************************************************/
long TunerSetFrequency(DEMOD_HANDLE handle,long frequency)
{
	INT32 nbsteps = 0;
	UINT8 chargepump = 0;
	
	TunerResetError();
	
	if (Tuner.StepSize > 0)
	{
		switch(Tuner.Type)
		{
			case TNR_EVALMAX:
				if (frequency < 1450000L)
				{
					chargepump = 0x40;
				}
				else if(frequency < 2000000L)
				{
					chargepump = 0x80;
				}
				else
				{
					chargepump = 0xC0;
				}
				
				Tuner.WrBuffer[3] = (Tuner.WrBuffer[3] & 0x3F) | chargepump;  
				break;
			
			default:
				break;
		}
		
		nbsteps = (frequency * 500) / Tuner.FreqFactor;
		nbsteps = (nbsteps + (500 * Tuner.IF)) / (Tuner.StepSize / 2);
		TunerSetNbSteps(handle,nbsteps);
	}
	
	return TunerGetFrequency();
}


/*****************************************************
**FUNCTION	::	TunerReadWrite
**ACTION	::	Read or write the tuner and put/use data in RdBuffer/WrBuffer
**PARAMS IN	::	mode ==> READ or WRITE 
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerReadWrite(DEMOD_HANDLE handle, BOOL bWriteOperation)
{
	unsigned char subadr;
	
	if (!Tuner.Error)
	{
		if (Tuner.Repeator)
		{
			RegSetField(handle,I2CT,1);
		}	
		
		if (TRUE == bWriteOperation)
		{
			unsigned char buff[11];

			buff[0] = Tuner.WrBuffer[0];
			buff[1] = Tuner.WrBuffer[1];
			buff[2] = Tuner.WrBuffer[2];
			buff[3] = Tuner.WrBuffer[3];
			buff[4] = Tuner.WrBuffer[2];
			buff[5] = Tuner.WrBuffer[3];
			buff[6] = Tuner.WrBuffer[0];
			buff[7] = Tuner.WrBuffer[1];
			buff[8] = Tuner.WrBuffer[0];
			buff[9] = Tuner.WrBuffer[1];
			buff[10] = Tuner.WrBuffer[2];
			i2c_write_raw(TUNER_WRITE_ADDRESS, buff, 11);
			buff[0] = Tuner.WrBuffer[2];
			buff[1] = Tuner.WrBuffer[3];
			buff[2] = Tuner.WrBuffer[0];
			RegSetField(handle,I2CT,1);
			i2c_write_raw(TUNER_WRITE_ADDRESS, buff, 3);
			buff[0] = Tuner.WrBuffer[0];
			buff[1] = Tuner.WrBuffer[1];
			RegSetField(handle,I2CT,1);
			i2c_write_raw(TUNER_WRITE_ADDRESS, buff, 2);
			buff[0] = Tuner.WrBuffer[0];
			RegSetField(handle,I2CT,1);
			i2c_write_raw(TUNER_WRITE_ADDRESS, buff, 1);
			buff[0] = Tuner.WrBuffer[2];
			RegSetField(handle,I2CT,1);
			i2c_write_raw(TUNER_WRITE_ADDRESS, buff, 1);
		}
		else
		{
			switch (Tuner.PLL)
			{
				case PLL_TUA6100:
					subadr = 0x80;
					i2c_read_raw(TUNER_READ_ADDRESS, &subadr, 1);
					if (Tuner.Repeator)
						RegSetField(handle,I2CT,1);

				default:
					i2c_read_raw(TUNER_READ_ADDRESS, Tuner.RdBuffer, Tuner.RdSize);
					break;
			}
		}
	}
}


/*****************************************************
**FUNCTION	::	TunerGetTunerLock
**ACTION	::	Read the tuner state
**PARAMS IN	::	NONE 
**PARAMS OUT::	NONE  
**RETURN	::	1 if lock, 0 otherwyse
*****************************************************/
INT32 TunerGetTunerLock(DEMOD_HANDLE handle)
{
	unsigned char byte;
	
	TunerResetError();
	TunerReadWrite(handle, FALSE);
	
	if(!Tuner.Error)
	{
		switch(Tuner.PLL)
		{
			case PLL_TUA6100:
				byte = 0x80;
				break;
			
			default:
				byte = 0x40;
				break;
		}
		
		if (Tuner.RdBuffer[0] & byte)
		{
			//tr_printf(("TUNER is LOCKED!\n"));

			return 1;
		}
	    
		return 0;
	}
	
	return 0;
}

#endif // SATELLITE_299

#endif // FTA_SUPPORT