reg0299.c

stv0299资料

									FieldGetVal(M),
									FieldGetVal(P));	/*	Compute master clock freq	*/
}

/*****************************************************
**FUNCTION	::	CalcDerotatorFrequency
**ACTION	::	Compute Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
long CalcDerotatorFrequency(int derotmsb,int derotlsb, long fm)
{
	long dfreq;
	short int  Itmp;
		
	Itmp = (derotmsb<<8)+derotlsb;
	dfreq =(((long)Itmp)*(fm/10000L))/65536L;
	dfreq *= 10;
	
	return dfreq; 
}

/*****************************************************
**FUNCTION	::	RegGetDerotatorFreq
**ACTION	::	Compute Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
long RegGetDerotatorFreq(void)
{
	/*	Read registers	*/
	RegGetRegisters(R_CFRM,2);   
	
	return CalcDerotatorFrequency(FieldGetVal(DEROTATORFREQUENCYMSB),
									FieldGetVal(DEROTATORFREQUENCYLSB), 
									RegGetMasterFreq());  	
}

/*****************************************************
**FUNCTION	::	CalcAuxClkFrequency
**ACTION	::	Compute Auxiliary clock frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Auxiliary Clock frequency
*****************************************************/
long CalcAuxClkFrequency(int k, int m, int acr)
{
	long aclk,factor;
	int function,value;
	
	function = acr>>5;
	value = acr & 0x1F;    
	
	switch(function)
	{
		case 0:
			aclk = 0;
		break;
	
		case 1:
			if(value)
				aclk = CalcVCOFrequency(k,m)/8/value;
			else
				aclk = CalcVCOFrequency(k,m)/8;  
		break;
		
		default:
			factor = 8192L*PowOf2(function-2);
			aclk = CalcVCOFrequency(k,m)/factor/(32+value);
		break;
	}
	
	return aclk; 
}

/*****************************************************
**FUNCTION	::	RegGetAuxFreq
**ACTION	::	Read registers and compute Auxiliary clock frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Auxiliary Clock frequency
*****************************************************/
long RegGetAuxFreq(void)
{
	/*	Read registers	*/
	RegGetOneRegister(R_RCR);
	RegGetOneRegister(R_ACR);
	
	return CalcAuxClkFrequency(FieldGetVal(K),
								FieldGetVal(M),
								FieldGetVal(ACR));	/*	Compute auxiliary clock freq	*/   
}


int RegGetErrorCount(void)
{
	int lsb,msb;
	
	/* Do not modified the read order (lsb first) */
	lsb = RegGetField(ERRCNTLSB);
	msb = RegGetField(ERRCNTMSB);
	return (MAKEWORD(msb,lsb));
}

void RegSetErrorCount(int Value)
{
	RegSetField(ERRCNTMSB,MSB(Value));
	RegSetField(ERRCNTLSB,LSB(Value));
}






/*
**
**------------------------------------------------------------------------------
**
**								int GetRollOff(void)
**
**  Simple function whichs read the register 00h  bit bit1 and which sets
**  corresponding Nyquist filter roll-off value.
**------------------------------------------------------------------------------
**
*/
int  RegGetRollOff(void)
{
	if ( RegGetField(NYQUISTFILTER)==1 )
		return 20;
	else
		return 35;
}
/*
**
*/
void  RegSetRollOff(int _Value)
{
	if(_Value == 35)
		RegSetField(NYQUISTFILTER,0);
	else
		RegSetField(NYQUISTFILTER,1);
}


long BinaryFloatDiv(long n1, long n2, int precision)
{
	int i=0;
	long result=0;
	
	/*	division de N1 par N2 avec N1<N2	*/
	while(i<=precision) /*	n1>0	*/
	{
		if(n1<n2)
		{
			result*=2;      
			n1*=2;
		}
		else
		{
			result=result*2+1;
			n1=(n1-n2)*2;
		}
		i++;
	}
	
	return result;
}



/*****************************************************
**FUNCTION	::	CalcSymbolRate
**ACTION	::	Compute symbol frequency
**PARAMS IN	::	Hbyte	->	High order byte
**				Mbyte	->	Mid byte
**				Lbyte	->	Low order byte
**PARAMS OUT::	NONE
**RETURN	::	Symbol frequency
*****************************************************/
long CalcSymbolRate(int Hbyte,int Mbyte,int Lbyte)
{
	long Ltmp,Ltmp2;
	long Mclk;

	Mclk =  RegGetMasterFreq() / 4096L;	/* Fm_clk*10/2^20 */
	Ltmp = (((long)Hbyte<<12)+((long)Mbyte<<4))/16;
	Ltmp *= Mclk;
	Ltmp /=16;
	Ltmp2=((long)Lbyte*Mclk)/256;     
	Ltmp+=Ltmp2;
	
	return Ltmp;
}

long RegSetSymbolRate(long SymbolRate)
{
	unsigned long Result;
	long MasterClock;
	
	/*
	** in order to have the maximum precision, the symbol rate entered into
	** the chip is computed as the closest value of the "true value".
	** In this purpose, the symbol rate value is rounded (1 is added on the bit
	** below the LSB )
	*/
	MasterClock=RegGetMasterFreq();  
	Result = BinaryFloatDiv(SymbolRate,MasterClock,20);       
	
	FieldSetVal(SYMB_FREQH,(Result>>12)&0xFF);
	FieldSetVal(SYMB_FREQM,(Result>>4)&0xFF);
	FieldSetVal(SYMB_FREQL,Result&0x0F);
	
	RegSetRegisters(R_SFRH,3);     
	
	return(SymbolRate) ;
}

/*****************************************************
**FUNCTION	::	RegGetSymbolRate
**ACTION	::	Return the symbol rate
**PARAMS IN	::	NONE	
**PARAMS OUT::	NONE
**RETURN	::	Symbol rate
*****************************************************/
long RegGetSymbolRate(void)
{
	RegGetRegisters(R_SFRH,3);
	
	return CalcSymbolRate(FieldGetVal(SYMB_FREQH),
							FieldGetVal(SYMB_FREQM),
							FieldGetVal(SYMB_FREQL)); 	
}

/*****************************************************
**FUNCTION	::	RegIncrSymbolRate
**ACTION	::	add a correction to the symbol rate
**PARAMS IN	::	correction	-> correction	
**PARAMS OUT::	NONE
**RETURN	::	New symbol rate
*****************************************************/
long RegIncrSymbolRate(long correction)
{
	long Ltmp	  ;
	
	RegGetRegisters(R_SFRH,3);
	
	Ltmp = (long)FieldGetVal(SYMB_FREQH)<<12;    
	Ltmp += (long)FieldGetVal(SYMB_FREQM)<<4;
	Ltmp += FieldGetVal(SYMB_FREQL);

	Ltmp += correction;

	FieldSetVal(SYMB_FREQH,(Ltmp>>12)&0xFF);
	FieldSetVal(SYMB_FREQM,(Ltmp>>4)&0xFF);
	FieldSetVal(SYMB_FREQL,Ltmp&0x0F);
	
	RegSetRegisters(R_SFRH,3);     
	
	return	RegGetSymbolRate();
}

/*****************************************************
**FUNCTION	::	CalcAGC1TimeConstant
**ACTION	::	compute AGC1 time constant
**PARAMS IN	::	m1			->	AGC1 reference value   
**				fm			->	Master clock frequency (MHz)
**				betaagc1	->	BeatAgc1
**PARAMS OUT::	NONE
**RETURN	::	AGC1 time constant (us)
*****************************************************/
long CalcAGC1TimeConstant(int m1,long fm,int betaagc1)
{
	long  Tagc1;
	
	if((m1==0)||(fm==0)) 
		return(0);

	Tagc1 = 67108864L;			/*	2^26	*/
	Tagc1 /= PowOf2(betaagc1);	/*	2^betaagc1	*/
	Tagc1 /= m1;
	Tagc1 /= (fm/10000);		/*	Result is in mS*10	*/
	
	return Tagc1;
}

/*****************************************************
**FUNCTION	::	RegGetAGC1TimeConstant
**ACTION	::	compute AGC1 time constant
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	AGC2 time constant
*****************************************************/
long RegGetAGC1TimeConstant(void)
{
	long fm;
	
	RegGetOneRegister(R_AGC1C);
	RegGetOneRegister(R_AGC1R);    
	RegGetRegisters(R_RCR,2);	/*	RCR,MCR		*/
	
	fm=CalcMasterClkFrequency(FieldGetVal(STDBY),
								FieldGetVal(DIRCLK),
								FieldGetVal(K),
								FieldGetVal(M),
								FieldGetVal(P));
								
	return CalcAGC1TimeConstant(FieldGetVal(AGC1_REF),
								fm,
								FieldGetVal(BETA_AGC1));    
}

/****************************************************
**FUNCTION	::	CalcAGC2TimeConstant
**ACTION	::	compute AGC2 time constant
**PARAMS IN	::	agc2coef	->	AGC2 coeficient
**				m1			->	AGC1 reference value
**				fm			->	Master clock frequency (MHz)
**PARAMS OUT::	NONE
**RETURN	::	AGC2 time constant (ns)
*****************************************************/
long CalcAGC2TimeConstant(long agc2coef, long m1, long fm)
{
	long	BetaAgc2,
			Tagc2=0;
	
	if((m1!=0) && (fm!=0))
	{
		BetaAgc2=PowOf2((agc2coef-1)*2);
		
		Tagc2=60000*10000;
		Tagc2/=(fm/1000); 
		Tagc2/=m1*BetaAgc2; 
		Tagc2*=100;
	}
	
	return Tagc2;
}
  
/*****************************************************
**FUNCTION	::	RegGetAGC2TimeConstant
**ACTION	::	compute AGC2 time constant
**PARAMS IN	::	agc2coef	->	AGC2 coeficient
**				m1			->	AGC1 reference value
**				fm			->	Master clock frequency
**PARAMS OUT::	NONE
**RETURN	::	AGC2 time constant
*****************************************************/
long RegGetAGC2TimeConstant(void)
{
	long fm;
	
	RegGetOneRegister(R_AGC1R);
	RegGetOneRegister(R_AGC2O);
	RegGetOneRegister(R_RCR);
	RegGetOneRegister(R_MCR);
	
	fm=CalcMasterClkFrequency(FieldGetVal(STDBY),
								FieldGetVal(DIRCLK),
								FieldGetVal(K),
								FieldGetVal(M),
								FieldGetVal(P));
								
	return CalcAGC2TimeConstant(FieldGetVal(AGC2COEF),
								FieldGetVal(AGC1_REF),
								fm);    
}

/*****************************************************
**FUNCTION	::	RegGetTimingLocked
**ACTION	::	Check the state of the timing loop
**PARAMS IN	::	agc2coef	->	AGC2 coeficient
**				m1			->	AGC1 reference value
**				fm			->	Master clock frequency
**PARAMS OUT::	NONE
**RETURN	::	Boolean ->true if timing loop is locked
*****************************************************/
int RegGetTimingLocked(void)
{
	int locked,
		TimingFreq;
		
	unsigned char Sr[3];
		
	locked=RegGetField(TLIR);
	
	if(locked>42)
	{
		if(locked>48)
			locked = 1;
		else
		{
			RegGetRegisters(R_SFRH,3);	/*	Read symbol rate registers	*/
			
			Sr[0] = FieldGetVal(SYMB_FREQH);	/*	Save symbol rate registers	*/    
			Sr[1] = FieldGetVal(SYMB_FREQM);  
			Sr[2] = FieldGetVal(SYMB_FREQL);  
			
			TimingFreq = CalcSymbolRate(Sr[0],Sr[1],Sr[2]); 
			RegSetSymbolRate(TimingFreq-(TimingFreq/100));
			
			if(RegGetField(TLIR) < locked)
				locked = 1;
			else 
				locked = 0;
			
			FieldSetVal(SYMB_FREQH,Sr[0]);
			FieldSetVal(SYMB_FREQM,Sr[1]);
			FieldSetVal(SYMB_FREQL,Sr[2]);
	
			RegSetRegisters(R_SFRH,3);	/*	Write symbol rate registers	*/      
		}
	}
	else locked = 0;

	return locked;
}

/*=====================================================
**=====================================================
**||||                                             ||||
**||||           F22 GENERATION FACILITIES         ||||
**||||                                             ||||
**=====================================================
**===================================================*/
void  RegF22On(void)
{
	/*RegSetField(F22OUTPUT,1); */
}

void  RegF22Off(void)
{
	/*RegSetField(F22OUTPUT,0);	*/
}


/*=====================================================
**=====================================================
**||||                                             ||||
**||||           TRIGGER FACILITIES                ||||
**||||                                             ||||
**=====================================================
**===================================================*/
void RegTriggerOn(void)
{
	if(RegTrigger == YES)
		/* I/O = 1 */
		RegSetField(DACMODE,1);
}

void RegTriggerOff(void)
{
	if(RegTrigger == YES)
		/* I/O = 0 */
		RegSetField(DACMODE,0); 
}

FLAG RegGetTrigger(void)
{
	return(RegTrigger);
}

void RegSetTrigger(FLAG _Trigger)
{
	RegTrigger = _Trigger;
}


/*{{{ QPSK0299_PrintAllFields ()*/
void  QPSK0299_PrintAllFields ( void )
{
   int   iFieldCount;

   DEBUG_PRINT ( ( "\n========================================\n" ) );
   DEBUG_PRINT ( ( "STv0299 Software Register Field Contents\n" ) );
   DEBUG_PRINT ( ( "========================================\n\n" ) );
	for ( iFieldCount = 0; iFieldCount < NBFIELD; iFieldCount++ )
   {
      DEBUG_PRINT ( ( "%-29s   @%02X => Val[%02X] Reg[%02X]\n",
            FieldMap [ iFieldCount ] . Name,
            ( int ) RegMap [ FieldMap [ iFieldCount ] . Reg ] . Addr,
            FieldGetVal ( iFieldCount ),
            ( int ) RegMap [ FieldMap [ iFieldCount ] . Reg ] . Value ) );
   }

   DEBUG_PRINT ( ( "\n" ) );

}
/*}}}*/

/*{{{ QPSK0299_PrintAllReg ()*/
void  QPSK0299_PrintAllReg ( void )
{
   int   iReg;

   DEBUG_PRINT ( ( "\n==================================\n" ) );
   DEBUG_PRINT ( ( "STv0299 Software Register Contents\n" ) );
   DEBUG_PRINT ( ( "==================================\n\n" ) );
	for ( iReg = 0; iReg < NBREG; iReg++ )
   {
      int   iHwRegContent;

      iHwRegContent = RegGetOneRegister ( iReg );
      DEBUG_PRINT ( ( "%-29s   @%02X => SW[%02X] HW[%02X] RST[%02X]\n",
            RegMap [ iReg ] . Name,
            ( int ) RegMap [ iReg ] . Addr & 0xFF,
            ( int ) RegMap [ iReg ] . Value & 0xFF,
            iHwRegContent & 0xFF,
            ( int ) RegMap [ iReg ] . Reset & 0xFF ) );
   }

   DEBUG_PRINT ( ( "\n" ) );

#if   0
   QPSK0299_PrintAllFields ( );
#endif

}
/*}}}*/

/*{{{ RegGetValue ()*/
int   RegGetValue ( int reg_id )
{
   return   RegMap [ reg_id ] . Value;
}
/*}}}*/