gx1101.c

做STB的朋友接好了,国芯调协器软件包说明介绍.

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

        Copyright(C) 2004 , HANGZHOU GUOXIN SCIENCE AND TECHNOLOGY CO.,LTD, all right reserved.

        Product : DVB-S_GX1101 Demo Software

        Date    : 2005.09.14
        Author  : Guoxin
        Purpose	: Drive GX1101 
*******************************************************************************************/
#include	"gx1101.h"
#include 	"dvb_replace.h"
/*******************************************************************************************/
/* Global variables */
static u8          	u8ChipID;  // 01:GX1101
#ifdef DVB_TUNER_MAX2118
static u8	tuner_device_id	= MX2118_DEVICE_ID;
u8  byte[6] = {0x03, 0xb6, 0x3d, 0x7f, 0x02, 0x0a};//CP=3,DL=0
#else
static u8	tuner_device_id;
#endif


unsigned int Baud;//KHz
unsigned char ChannelCount =0;
static bool8 b8InitSuccess=FALSE;
/*******************************************************************************************
Function    : gx1101_Initial()
Description	: Initial GX1101 Device
Input       : none
Output      : b8InitSuccess
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Initial(void)
{
    	GX1101_STATUS		status;
    	u8					buffer[2];
    	u8 					i;
    	u8ChipID        = 0;
	for(i = 0;i< 5;i++)
	{
		buffer[0] = 0x00;
		buffer[1] = 0x00;
   		gx1101_Write_Registers(0x02, buffer, 2, FALSE);
		delay_ms(20);
  		buffer[0] = 0xc0; 
  		buffer[1] = 0xb3; //90.5MHz
  		gx1101_Write_Registers(0x02, buffer, 2, FALSE);
   		delay_ms(10);
	}
	buffer[0] = 0x80; //90.5MHz
	buffer[1] = 0x5a; 
	gx1101_Write_Registers(0x63, buffer, 2, FALSE);
	
	if ((status = gx1101_Read_Registers(GX1101_ID, buffer, 1, FALSE)) != GX1101_NO_ERROR)
		return GX1101_CB_ERROR;

	if (buffer[0] == GX1101_CHIP_ID)
	{
	    u8ChipID = buffer[0];
	}
	else
	{
		return GX1101_CB_ERROR;
	}
	
	buffer[0] = 0x3c; 
	gx1101_Write_Registers(GX1101_CRL_PARA, buffer, 1, FALSE);

	buffer[0] = 0x07;
   	gx1101_Write_Registers(GX1101_GPOP0, buffer, 1, FALSE);

	buffer[0] = 0x10;
   	gx1101_Write_Registers(GX1101_TRL_PARA, buffer, 1, FALSE);
   	buffer[0] = 0x72;
   	gx1101_Write_Registers(0x66, buffer, 1, FALSE);
	//buffer[0] = 0xb4;
	//gx1101_Write_Registers(GX1101_IQ_SWAP, buffer, 1, FALSE);
	b8InitSuccess=TRUE;
	return GX1101_NO_ERROR;
}
/*******************************************************************************************
Function    : gx1101_Write_Registers()
Description	: Write registers via Serial 2-Wire Control Bus	  
Input       : u8Address,*pu8Buffer,no_of_bytes,cb_tuner_access_on
Output      : none 
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Write_Registers(u8 u8Address, u8 *pu8Buffer, u8 no_of_bytes, bool8 cb_tuner_access_on)
{
	u8			i;
	u8 u8Deviceid;

	u8Deviceid = GX1101_DEVICE_ID;
	if (cb_tuner_access_on)
	{		
		u8Address=*pu8Buffer;/*because write tuner don't need register address*/
		pu8Buffer++;
		no_of_bytes--;
		u8Deviceid=tuner_device_id; 
	}
	
	if ( DVB_CB_Write_Burst (u8Deviceid, u8Address, pu8Buffer, no_of_bytes)==FALSE )
		return GX1101_CB_ERROR;
	
    return GX1101_NO_ERROR;
}
/*******************************************************************************************
Function    : gx1101_Read_Registers()
Description	: Read registers via Serial 2-Wire Control Bus	       
Input       : u8Address,*pu8Buffer,no_of_bytes,cb_tuner_access_on
Output      : none 
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Read_Registers(u8 u8Address, u8 *pu8Buffer, u8 no_of_bytes, bool8 cb_tuner_access_on)
{
	u8	u8Deviceid= GX1101_DEVICE_ID;
	
	if (cb_tuner_access_on)
		u8Deviceid = tuner_device_id; 
	else
		u8Deviceid = GX1101_DEVICE_ID;

	if (!cb_tuner_access_on)
	{
		if (DVB_CB_WriteNoStop (u8Deviceid, u8Address)==FALSE )
		{
			return GX1101_CB_ERROR;
		}
	}
	if ( DVB_CB_Read_Burst (u8Deviceid, pu8Buffer, no_of_bytes)==FALSE )
	{
		return GX1101_CB_ERROR;
	}
	return GX1101_NO_ERROR;
}
/*******************************************************************************************
Function    : gx1101_Open_Tuner_CB()
Description	: Open Secondary Serial 2-Wire Control Bus to access the tuner
Input       : none
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Open_Tuner_CB(void)
{
    GX1101_STATUS	status;
	u8				buffer[2];
	if ((status = gx1101_Read_Registers(GX1101_GLB_CTRL, buffer, 1, FALSE)) != GX1101_NO_ERROR)
		return status;
	//buffer[0] = buffer[0] & 0xfe;
	if(u8ChipID == GX1101_CHIP_ID)
	    buffer[0] = buffer[0] |GX1101_GLB_CTRL_CB_OPEN;
	else
	    buffer[0] = 0x00;
	status = gx1101_Write_Registers(GX1101_GLB_CTRL, buffer, 1, FALSE);
	return status;
}		
/*******************************************************************************************
Function    : gx1101_Close_Tuner_CB()
Description	: Close Secondary Serial 2-Wire Control Bus to access the tuner 
Input       : none
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Close_Tuner_CB(void)
{
    GX1101_STATUS	status;
	u8				buffer[2];
	if ((status = gx1101_Read_Registers(GX1101_GLB_CTRL, buffer, 1, FALSE)) != GX1101_NO_ERROR)
		return status;
	buffer[0] = buffer[0] & 0xfc;
	if(u8ChipID == GX1101_CHIP_ID)
	    buffer[0] = buffer[0] |GX1101_GLB_CTRL_CB_CLOSE;
	else
	    buffer[0] = 0x00;
	status = gx1101_Write_Registers(GX1101_GLB_CTRL, buffer, 1, FALSE);
	return status;
}
#ifdef DVB_TUNER_MAX2118
void calcu_divider_byte(unsigned long FREQn)//MHz
{
	unsigned long  dataa;
    unsigned int uiStepSize;
    unsigned long long_tmp;
    unsigned long sr;
	unsigned char div,vcoflag,lpf;
    unsigned long VCO;
    long_tmp = byte[2];
    long_tmp = (long_tmp >> 5) & 0x07;
    long_tmp = 2<<long_tmp;
    long_tmp = MHZ_XTAL_FREQ*1000000 / long_tmp;
    long_tmp /= 1000;
    
    uiStepSize = (unsigned int)long_tmp;
    
    dataa = FREQn * 1000;
    dataa /= uiStepSize;

    byte[0] = (dataa >> 8) & 0x7F;
    byte[1] = dataa & 0xFF;   

    if(FREQn >= 1125)
	{
        byte[0] |= 0x80;
		div = 2;
	}
	else
	{
        byte[0] &= 0x7F;
		div = 4;
	}
    VCO = FREQn*div;

	if(VCO<=2432)
	     vcoflag =0;
	else if(VCO<=2710)
	 	 vcoflag =1; 
	else if(VCO<=3024)
	 	 vcoflag =2;
	else if(VCO<=3340)
	 	 vcoflag =3; 
	else if(VCO<=3726) 
	 	 vcoflag =4;
	else if(VCO<=4142) 
	 	 vcoflag =5; 
	else if(VCO<=4492)
	 	 vcoflag =6; 
	else if(VCO<=5022)
	 	 vcoflag =7;

	byte[2]&=0xf8;
	byte[2]|= vcoflag;
/*
     * calculate the LPF
     */
	if(Baud<3000)
		Baud = 3000;
//	if(Baud<=5000)
//		sr = (((unsigned long)Baud)*135)/200+5000;
//	else
	sr = (((unsigned long)Baud)*135)/200+8000;
	sr = sr*MX2118_M;
	sr = sr/MHZ_XTAL_FREQ;
	if(sr < 4000)
		sr = 4000;
	sr = ((sr - 4000)*6897)/1000000L;
	lpf = (unsigned char)(sr+1);
	if(lpf>0x7f)
	 	lpf =0x7f;
    byte[3] = lpf;
}
/*******************************************************************************************/
GX1101_STATUS gx1101_tuner_write_max2118(void)
{
	if ( DVB_CB_Write_Burst (MX2118_DEVICE_ID, 0x00, byte, 6)==FALSE )
		return GX1101_CB_ERROR;
	return GX1101_NO_ERROR;
}
/****************************************************************************/
#endif

/*******************************************************************************************
Function    : gx1101_Program_Tuner()
Description	: Program tuner through gx1101 repeater	  
Input       : lnb_params
Output      : none
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Program_Tuner(GX1101_LNB_PARAMS lnb_params)
{
	GX1101_STATUS	status;
	u8				buffer[2];
	u32				freq;
	freq = lnb_params.KHz_tuner_freq/1000;
    	calcu_divider_byte(freq);//MHz
	gx1101_Open_Tuner_CB();
    	gx1101_tuner_write_max2118();
	gx1101_Close_Tuner_CB();
#if 0	
	delay_ms(20);
	gx1101_Read_Registers(GX1101_CHIP_STATE, buffer, 1, FALSE);
	buffer[1] = buffer[0];
	gx1101_Read_Registers(GX1101_INTENSITY, buffer, 1, FALSE);
	if((buffer[1]&0x80 == 0x00) || (buffer[0] == 0xff))
	{//AGC fail or intensity=0
		if(lnb_params.KBd_rate >= 16000)
			byte[5] = (byte[5] & 0xe0)||0x08;//0x08
		else
			byte[5] = (byte[5] & 0xe0)||0x05;//0x05
		gx1101_Open_Tuner_CB();
		gx1101_tuner_write_max2118();
		gx1101_Close_Tuner_CB(); 
		byte[5] = 0x0a;
	}
#endif
	return	GX1101_NO_ERROR;
}
/*******************************************************************************************
Function    : gx1101_Get_Channel_Status()
Description	: Obtaining channel parameters 	        
Input       : KHz_tuner_freq
Output      : channel_params 
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Get_Channel_Status(u32 KHz_tuner_freq , GX1101_CHANNEL_PARAMS *channel_params)
{	
	GX1101_STATUS			status;
	u8						buffer[2];
	u16						rate;
	u32						krate;
	u8						loopCount ;
	s32						value1,value2,value3;
	//printf("\n>> KHz_tuner_freq = %ld ",KHz_tuner_freq);
	if ((status = gx1101_Read_Registers(GX1101_SYM_RATE_L, buffer, 2, FALSE)) != GX1101_NO_ERROR)
    	return status;
	rate = (u16)(buffer[1]*256 + buffer[0]);
	krate = (u32)rate;
	krate = (krate * 1000)/1024;
	channel_params->KBd_rate = krate;
	
 	if ((status = gx1101_Read_Registers(GX1101_ERR1_L, buffer, 2, FALSE)) != GX1101_NO_ERROR)
    		return status;
	value1 = buffer[1] *256 + buffer[0];
	if (buffer[1]&0x80) value1-=0x10000;
	//printf("\n>> buffer[0] = 0x%hx ,buffer[1] = 0x%hx,value1 = %ld",buffer[0],buffer[1],value1);
	
	if ((status = gx1101_Read_Registers(GX1101_ERR2_L, buffer, 2, FALSE)) != GX1101_NO_ERROR)
    		return status;
	value2 = buffer[1] *256 + buffer[0];
	if (buffer[1]&0x80) value2-=0x10000;
	//printf("\n>> buffer[0] = 0x%hx ,buffer[1] = 0x%hx,value2 = %ld",buffer[0],buffer[1],value2);
	value3 = value1*GX1101_SYSCLK_KHZ + value2*(s32)channel_params->KBd_rate;
	value3 = value3/65536;
	//printf("\n>> value3 = %ld",value3);
	//printf("\n>> gx1101_get_channel_status2 value3 = %d ",(int)value3);
	//printf("\n>> gx1101_get_channel_status channel_params->KBd_rate = %ld ",channel_params->KBd_rate);
	channel_params->KHz_center_freq = (u32)((s32)KHz_tuner_freq + value3);
	
#if PRINT_TEST
	printf("\n>> channel_params->KHz_center_freq = %ld ",(unsigned long)channel_params->KHz_center_freq);
#endif
   //printf("\n>>get_channel_status channel_params->KBd_rate=%ld\n",(unsigned long)channel_params->KBd_rate );

	//printf("\n>> gx1101_get_channel_status1 channel_params->KHz_center_freq = %ld ",channel_params->KHz_center_freq);
	return GX1101_LOCK;
}
/*******************************************************************************************
Function    : gx1101_Set_Blind_Enable()
Description	: Enable or Disable Blind Scan 
Input       : On or Off
Return      : GX1101_STATUS code
*******************************************************************************************/
GX1101_STATUS gx1101_Set_Blind_Enable(u8 OnOff)
{
    GX1101_STATUS	status;
	u8			buffer[2];
	if(u8ChipID == GX1101_CHIP_ID)
	    buffer[0] = OnOff;
	else
	    buffer[0] = 0x00;
	status = gx1101_Write_Registers(GX1101_BLIND_SEL, buffer, 1, FALSE);
		return status;
}
Check_TPInfo gx1101_tpItem[]=
{
	{3200,   1000},	
	{3200,   1000},	
	{3200,   1000},	
	{3200,   1000}
};
/*判断当前super search或者盲扫出来的频点是否和其他频点重复了,与前面3个频点比较*/
bool8 check_gx1101_tpItem(u16 u16TPFrequency,u16 u16SymbolRate)
{
	unsigned char i=NEEDFIND_NUM;
	do
	{
		if((u16TPFrequency> (gx1101_tpItem[i-1].u16TPFrequency-2))
			&&(u16TPFrequency < (gx1101_tpItem[i-1].u16TPFrequency+2))
			&&(u16SymbolRate> (gx1101_tpItem[i-1].u16SymbolRate-6))
			&&(u16SymbolRate<(gx1101_tpItem[i-1].u16SymbolRate+6)))
		{//转发器参数相同
			return TRUE;
		}
	}
	while(i--);
	for(i = 0;i<(NEEDFIND_NUM-1);i++)
	{
		gx1101_tpItem[i].u16TPFrequency = gx1101_tpItem[i+1].u16TPFrequency;
		gx1101_tpItem[i].u16SymbolRate = gx1101_tpItem[i+1].u16SymbolRate;
	}
	gx1101_tpItem[NEEDFIND_NUM-1].u16TPFrequency = u16TPFrequency;
	gx1101_tpItem[NEEDFIND_NUM-1].u16SymbolRate =u16SymbolRate;
	return FALSE;
}
#if 1
EPTPinf_s		result[100]; //singal result and the last results.
bool8 gx1101_super_search(u32 u32KHz_tuner_freq/*950000~2150000*/,u32 u32KBd_rate,
								u16 MHz_local_frequency,EPTPinf_s ReChannel)
{
	u16		if_frequency;		
	u8		buffer[2];
	SCAN_TP_T Cre;
	u16 		local_frequency;
	GX1101_LNB_PARAMS		lnb_params;	

	gx1101_Set_Blind_Enable(GX1101_SET_BLIND_DISABLE);
	local_frequency = MHz_local_frequency;
	lnb_params.KHz_tuner_freq = u32KHz_tuner_freq;
	lnb_params.KBd_rate = u32KBd_rate;
	lnb_params.enPolar = ReChannel.lnb;
	Baud = u32KBd_rate;
	if(gx1101_Set_Program(&lnb_params) == TRUE)
	{//如果TP能锁定，则保存TP
		ReChannel.benzhen = (unsigned int)local_frequency;
    		ReChannel.baud = (unsigned int)u32KBd_rate;
		if_frequency = (u16)((u32KHz_tuner_freq+500)/1000);
		ReChannel.Fre = (unsigned int)if_frequency;
	#ifdef SUPER_SEARCH
		if(check_gx1101_tpItem(ReChannel.Fre,ReChannel.baud) == FALSE)
	#endif
		{
			result[ChannelCount] = ReChannel;//save transponder's parameter
			ChannelCount++;
		}
	}
	else
	{	
		//printf("super search failed\n");
	}

	buffer[0] = 0x72;
	gx1101_Write_Registers(0x66, buffer, 1, FALSE);
	buffer[0] = 0;
	buffer[1] = 0;
   	if(gx1101_Write_Registers(GX1101_ERR1_L, buffer, 2, FALSE) != GX1101_NO_ERROR )
		return FALSE;
	if( gx1101_Set_Blind_Enable(GX1101_SET_BLIND_ENABLE) != GX1101_NO_ERROR)
		return FALSE;
	if(gx1101_Open_FD(TRUE) != GX1101_NO_ERROR)
		return FALSE;
	Baud = 45000;
	return TRUE;
}
void BlindSearch(char speed,u16 Local_Frequency)
{
	unsigned char	pol;
	unsigned int	TPlong; 
	EPTPinf_s		ReChannel;
	u16			if_frequency;		
   	u16			local_frequency;
	u32			KHz_tuner_freq_min;
	u32			KHz_tuner_freq_max;	
	u32			KHz_tuner_freq, khz_new_scan_step;
	GX1101_STATUS			status;
	bool8					scan_complete;
	s32						s32Process;
	GX1101_CHANNEL_PARAMS	channel_params;
	GX1101_LNB_PARAMS		lnb_params;	
	u8						buffer[2];
	u32						u32Offset;
	u8 						u8ProgressStart,u8Step;
	u8 						test_p= 0;
	bool8	bNeedFind[NEEDFIND_NUM]={1,1,1,1};
	
	lnb_params.enPolar = POL_VERTICAL;
	channel_params.lnb_polar = POL_VERTICAL;
	gx1101_Set_Blind_Enable(GX1101_SET_BLIND_ENABLE);