reg0297.c.bak

stv0297 寄存器 tuner 驱动 5105 方案

	   	regsym = _ExtClk * regsym; /* _ExtClk in KHz */
	   	RegSymbolRate = regsym/256L ;/* 256 = 2**8 */
	}
	else if(regsym > 268435456L) /* 268435456L = 2**28 */
	                         /*             # 1.8 MBd (clock = 28.92 MHz) */
	{
	   	regsym = regsym/4096L;/* 4096L = 2**12 */
	   	regsym = _ExtClk * regsym; /* _ExtClk in KHz */
	   	RegSymbolRate = regsym/512L ;/* 512 = 2**9 */
	}
	else 
	{
	   	regsym = regsym/2048L;/* 2048L = 2**11 */
	   	regsym = _ExtClk * regsym; /* _ExtClk in KHz */
	   	RegSymbolRate = regsym/1024L;/* 1024 = 2**10 */
	}
	/*
	// As the clock is in KHz, the result must be multiplied by 1000 ; as the register contents
	// was divided by 2**21 instead of 2**32 (cf. data sheet), the result must be divied by 2**11
	// or 2048. At the end, it is necessary to perform a multiplication by 1000/2048 or 125/256.
	*/
	RegSymbolRate *= 125 ;
	RegSymbolRate /= 256 ;
	return(RegSymbolRate);
  }
  
/*---------------------------------+
NOTE: SetSymbolRate 
+----------------------------------*/
void RegSetSymbolRate(unsigned long _SymbolRate)
  {
	unsigned long ulong_tmp, ExtClk_tmp;
	RegSymbolRate = _SymbolRate ; // _SymbolRate is in Bd
	ulong_tmp = RegSymbolRate ;
	if(ulong_tmp > 8388607L) /* 8388608 = 2**23 */
	{
       		ulong_tmp *= 256 ;/* 256 = 2**8 */ 
       		ulong_tmp = ulong_tmp /_ExtClk ;   
       		ulong_tmp = ulong_tmp * 8192L;  /* 8192 = 2**13  */ 
       		ulong_tmp /= 1000 ;
       		ulong_tmp = ulong_tmp * 2048L;  /* 2048 = 2**11  */ 
	}
	else if(ulong_tmp > 4194304L) /* 4194304 = 2**22 */
	{
       		ulong_tmp *= 512 ;/* 512 = 2**9 */ 
       		ulong_tmp = ulong_tmp /_ExtClk;   
       		ulong_tmp = ulong_tmp * 8192L;  /* 8192 = 2**13  */ 
       		ulong_tmp /= 1000 ;
       		ulong_tmp = ulong_tmp * 1024L;  /* 1024 = 2**10  */ 
	}
	else if(ulong_tmp > 2097151L) /* 2097151 = 2**21 */
	{
       		ulong_tmp *= 1024 ;/* 1024 = 2**10 */ 
      	 	ulong_tmp = ulong_tmp /_ExtClk;   
       		ulong_tmp = ulong_tmp * 8192L;  /* 8192 = 2**13  */ 
       		ulong_tmp /= 1000 ;
       		ulong_tmp = ulong_tmp * 512L;  /* 512 = 2**9  */ 
	}
	else 
	{
       		ulong_tmp *= 2048 ;/* 2048 = 2**11 */ 
       		ulong_tmp = ulong_tmp /_ExtClk;   
       		ulong_tmp = ulong_tmp * 8192L;  /* 8192 = 2**13  */ 
       		ulong_tmp /= 1000 ;
       		ulong_tmp = ulong_tmp * 256L;  /* 256 = 2**8  */ 
	 }
	RegSetField(SYMB_RATE_0,ulong_tmp);
	RegSetField(SYMB_RATE_1,(ulong_tmp>>8));
	RegSetField(SYMB_RATE_2,(ulong_tmp>>16));
	RegSetField(SYMB_RATE_3,(ulong_tmp>>24));
	return;
  }


/*---------------------------+
NOTE:RegSweepOff
+----------------------------*/
void RegSweepOff(void)
  {
   int Value ;
   Value = RegGetOneRegister(CRL_10)   ;
   Value |= 0x30 ;
   Value &= 0xFC ;
   RegSetOneRegister(CRL_10,Value)   ;
   return ;
  }
/*---------------------------+
NOTE:RegSweepOn
+----------------------------*/
void RegSweepOn(void)
  {
   int Value ;
   Value = RegGetOneRegister(CRL_10)   ;
   Value &= 0xCF ;
   Value |= 0x03 ;
   RegSetOneRegister(CRL_10,Value)   ;
   return ;
  }
/*----------------------------+
NOTE:GetSweepRate 
+-----------------------------*/
short RegGetSweepRate(void)
  {
	short short_tmp  ;
	int   _SymbolRate;
	long  long_tmp   ;
	long_tmp  = RegGetField(SWEEP_LO);
	long_tmp += RegGetField(SWEEP_HI)<<8;
	_SymbolRate = RegSymbolRate / 0x10;	
	if (long_tmp & 0x00000800) 
	{
		long_tmp = (~long_tmp + 1) & 0x00000FFF;
		long_tmp = (long_tmp * _SymbolRate )/ 0x1000;	/* 0x1000 = 2**12 */
		long_tmp = (-long_tmp * 1000) / 0x1000;		/* 0x1000 = 2**12 */
	}
	else 
	{
		long_tmp = long_tmp & 0x00000FFF;
		long_tmp = (long_tmp * _SymbolRate)/ 0x1000;	/* 0x100  = 2**12 */
		long_tmp = (long_tmp * 1000) / 0x1000;	 	/* 0x1000 = 2**12 */
	}
	short_tmp = (short) long_tmp ;
	return(short_tmp); 
  }
  
/*----------------------------+
NOTE:SetSweepRate
+-----------------------------*/						
void RegSetSweepRate(short _FShift)
  {
	long long_tmp;
	short FShift ;
	unsigned long ulong_tmp ;
	FShift = _FShift ;  /* in ms */
	ulong_tmp = RegGetSymbolRate() ;  /* in Baud/s */
	if(ulong_tmp <= 0) 
		return ;
	long_tmp = FShift * 262144L ;  /* 262144 = 2*18 */
	ulong_tmp /= 1024 ;
	long_tmp /= (long) ulong_tmp ;
	long_tmp /= 1000 ;
 	RegSetField(SWEEP_LO,long_tmp & 0xFF);
	RegSetField(SWEEP_HI,(long_tmp>>8) & 0x0F);
	return;
  }

///*-------------------+
//NOTE:SetSweepReg 
//---------------------*/						
//void RegSetSweepReg(short swrate)
//  {
//	long tmp;
//	RegSetField(SWEEP_LO,(unsigned char)tmp);
//	RegSetField(SWEEP_HI,(unsigned char)(tmp>>8));
//	return;
//  }



/*-----------------------------------+
NOTE:SetFrequencyOffset 
+------------------------------------*/  
void RegSetFrequencyOffset(long _CarrierOffset)
 {
	long long_tmp;
	long CarrierOffset ;
	CarrierOffset = _CarrierOffset     ; /* in 0/000 of Fs */
	long_tmp = CarrierOffset * 26844L ; /* (2**28)/10000 */
	if(long_tmp < 0) long_tmp += 0x10000000 ;
	long_tmp &= 0x0FFFFFFF ;
	RegSetField(IPHASE_0,long_tmp);
	RegSetField(IPHASE_1,(long_tmp>>8));
	RegSetField(IPHASE_2,(long_tmp>>16));
	RegSetField(IPHASE_3,(long_tmp>>24)); 
	return;
  }
/*----------------------------------+
NOTE: GetFrequencyOffset 
+-----------------------------------*/  
long RegGetFrequencyOffset(void)
  {
  	long long_tmp;
  	//int  int_tmp ;
    	RegSetField(CRL_SNAPSHOT, 0xff) ;
	long_tmp   = RegGetField(IPHASE_0);
	long_tmp  += RegGetField(IPHASE_1)<<8;
	long_tmp  += RegGetField(IPHASE_2)<<16;
	long_tmp  += RegGetField(IPHASE_3)<<24;
	if (long_tmp >= 0x08000000)
	{
	   	long_tmp -= 0x10000000 ; /* 0x10000000 = 2**28  */
	}
	long_tmp /= 4096 ; // 2**12
        long_tmp *= (RegGetSymbolRate()/1000) ;
        long_tmp /= 65536; // 2**16
	//long_tmp /= 2684354L ; /* (2**28)/100 */
	return(long_tmp-12);
  }
  
/*------------------------+
NOTE:RegSetPMFAGCthreshold
+-------------------------*/
void RegSetPMFAGCthreshold(unsigned short val)
  {
	RegSetField(LOCK_THRES_LO,(unsigned char)val);
	RegSetField(LOCK_THRES_HI,(unsigned char)(val>>8));
	return;
  }
/*------------------------+
NOTE:RegGetPMFAGCthreshold
+-------------------------*/
unsigned short RegGetPMFAGCthreshold(void)
  {
 	unsigned short val;
	val  = RegGetField(LOCK_THRES_LO);
	val += RegGetField(LOCK_THRES_HI)<<8; 
	return(val);
  }
/*------------------------+
NOTE:RegGetBERTerror
+-------------------------*/
unsigned short RegGetBERTerror(void)
  {
 	unsigned short Value;
	Value  = RegGetField(ERRCOUNT_LO);
	Value += RegGetField(ERRCOUNT_HI)<<8; 
	return(Value);
  }
/*-------------------------+
NOTE:RegGetBERTcount
+--------------------------*/
unsigned short RegGetBERTcount(void)
  {
 	unsigned short Value;
	Value  = RegGetField(ERRCOUNT_LO);
	Value += RegGetField(ERRCOUNT_HI)<<8; 
	return(Value);
  }
/*-------------------------+
NOTE:RegGetBlkCounter
+--------------------------*/
unsigned short RegGetBlkCounter(void)
  {
 	unsigned short Value;
	Value =  RegGetField(BK_CT_LO);
	Value += RegGetField(BK_CT_HI)<<8;
	return(Value);
  }
/*-------------------------+
NOTE:RegGetCorrBlk
+--------------------------*/
unsigned short RegGetCorrBlk(void)
  {
 	unsigned short Value;
	Value =  RegGetField(CORR_CT_LO);
	Value += RegGetField(CORR_CT_HI)<<8;
	return(Value);
  }
/*-------------------------+
NOTE:RegGetUncorrBlk
+--------------------------*/
unsigned short RegGetUncorrBlk(void)
  {
 	unsigned short Value;
	Value =  RegGetField(UNCORR_CT_LO);
	Value += RegGetField(UNCORR_CT_HI)<<8;
	return(Value);
  }
  
/*-------------------------+
NOTE:RegTriggerOn
+--------------------------*/		 
void RegTriggerOn(void)
  {
   if(RegTrigger == M_NO) 
   	return ;
	 /* Output IFPWM = 0x7FFF */
	RegSetField(IF_PWM_HI,0x7F);
	RegSetField(IF_PWM_LO,0xFF);
   	/* PWM selection */
   	RegSetField(ITPWMSEL,0x01) ;
	return ;
  }
/*-------------------------+
NOTE:RegTriggerOff
+--------------------------*/
void RegTriggerOff(void)
  {
   if(RegTrigger == M_NO) return ;
   /* PWM deselection */
   RegSetField(ITPWMSEL,0x00) ;
   return ;
  }


//



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