reg0299.c

这是DVB tuner驱动部分和其它相关的源码和一些技术资料文档.

/*****************************************************
 **FUNCTION	::	RegGetTimingNaturalFrequency
 **ACTION	::	Read registers and compute natural clock frequency for timing loop
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Timing natural frequency
 *****************************************************/
long RegGetTimingNaturalFreq(STV0299_ControlBlock_t *Dev_p)
{
    long fs;

    RegGetOneRegister(Dev_p, R_AGC2O);
    RegGetOneRegister(Dev_p, R_RTC);
    RegGetOneRegister(Dev_p, R_SFRH);
    RegGetOneRegister(Dev_p, R_SFRM);
    RegGetOneRegister(Dev_p, R_SFRL);

    fs=CalcSymbolRate(Dev_p, FieldGetVal(Dev_p, SYMB_FREQH),
                      FieldGetVal(Dev_p, SYMB_FREQM),
                      FieldGetVal(Dev_p, SYMB_FREQL));

    return CalcTimingNaturalFrequency(Dev_p, FieldGetVal(Dev_p, AGC2_REF),
                                      FieldGetVal(Dev_p, BETA_TMG),
                                      fs);
}

/*****************************************************
 **FUNCTION	::	CalcTimingDampingFactor
 **ACTION	::	Compute damping factor for timing loop
 **PARAMS IN	::	m2		->	AGC2 reference level
 **				alphatmg->	Alpha timing
 **				betatmg ->	Beta timing
 **PARAMS OUT::	NONE
 **RETURN	::	Timing damping factor (*1000)
 *****************************************************/
long CalcTimingDampingFactor(int m2, int alphatmg, int betatmg)
{
    long DampFact=0;

    if((alphatmg>=0)&&(betatmg>=0))
    {
        DampFact=134*LongSqrt((long)m2*16)*PowOf2(alphatmg);   /* cast to eliminate compiler warning --SFS */
        DampFact/=LongSqrt(PowOf2(betatmg)*16);
    }

    return DampFact;
}

/*****************************************************
 **FUNCTION	::	RegGetTimingDampingFactor
 **ACTION	::	Read registers and compute damping factor for timing loop
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Timing damping factor
 *****************************************************/
long RegGetTimingDampingFactor(STV0299_ControlBlock_t *Dev_p)
{
    RegGetOneRegister(Dev_p, R_AGC2O);
    RegGetOneRegister(Dev_p, R_RTC);

    return CalcTimingDampingFactor(FieldGetVal(Dev_p, AGC2_REF),
                                   FieldGetVal(Dev_p, ALPHA_TMG),
                                   FieldGetVal(Dev_p, BETA_TMG));
}

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(STV0299_ControlBlock_t *Dev_p, int Hbyte,int Mbyte,int Lbyte)
{
    long Ltmp,Ltmp2;
    long Mclk;

    Mclk =  RegGetMasterFreq(Dev_p) / 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(STV0299_ControlBlock_t *Dev_p, 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(Dev_p);
    Result = BinaryFloatDiv(SymbolRate,MasterClock,20);

    FieldSetVal(Dev_p, SYMB_FREQH,(int)((Result>>12)&0xFF));   /* cast to eliminate compiler warning --SFS */
    FieldSetVal(Dev_p, SYMB_FREQM,(int)((Result>>4)&0xFF));    /* cast to eliminate compiler warning --SFS */
    FieldSetVal(Dev_p, SYMB_FREQL,(int)Result&0x0F);           /* cast to eliminate compiler warning --SFS */

    RegSetRegisters(Dev_p, R_SFRH,3);

    return(SymbolRate) ;
}

/*****************************************************
 **FUNCTION	::	RegGetSymbolRate
 **ACTION	::	Return the symbol rate
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Symbol rate
 *****************************************************/
long RegGetSymbolRate(STV0299_ControlBlock_t *Dev_p)
{
    RegGetRegisters(Dev_p, R_SFRH,3);

    return CalcSymbolRate(Dev_p, FieldGetVal(Dev_p, SYMB_FREQH),
                          FieldGetVal(Dev_p, SYMB_FREQM),
                          FieldGetVal(Dev_p, 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(STV0299_ControlBlock_t *Dev_p, long correction)
{
    long Ltmp	  ;

    RegGetRegisters(Dev_p, R_SFRH,3);

    Ltmp = (long)FieldGetVal(Dev_p, SYMB_FREQH)<<12;
    Ltmp += (long)FieldGetVal(Dev_p, SYMB_FREQM)<<4;
    Ltmp += FieldGetVal(Dev_p, SYMB_FREQL);

    Ltmp += correction;

    FieldSetVal(Dev_p, SYMB_FREQH,(int)((Ltmp>>12)&0xFF));   /* cast to eliminate compiler warning --SFS */
    FieldSetVal(Dev_p, SYMB_FREQM,(int)((Ltmp>>4)&0xFF));    /* cast to eliminate compiler warning --SFS */
    FieldSetVal(Dev_p, SYMB_FREQL,(int)(Ltmp&0x0F));         /* cast to eliminate compiler warning --SFS */

    RegSetRegisters(Dev_p, R_SFRH,3);

    return	RegGetSymbolRate(Dev_p);
}

/*****************************************************
 **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(STV0299_ControlBlock_t *Dev_p)
{
    long fm;

    RegGetOneRegister(Dev_p, R_AGC1C);
    RegGetOneRegister(Dev_p, R_AGC1R);
    RegGetRegisters(Dev_p, R_RCR,2);	/*	RCR,MCR		*/

    fm=CalcMasterClkFrequency(Dev_p, FieldGetVal(Dev_p, STDBY),
                              FieldGetVal(Dev_p, DIRCLK),
                              FieldGetVal(Dev_p, K),
                              FieldGetVal(Dev_p, M),
                              FieldGetVal(Dev_p, P));

    return CalcAGC1TimeConstant(FieldGetVal(Dev_p, AGC1_REF),
                                fm,
                                FieldGetVal(Dev_p, 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((int)(agc2coef-1)*2);  /* cast to eliminate compiler warning --SFS */

        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(STV0299_ControlBlock_t *Dev_p)
{
    long fm;

    RegGetOneRegister(Dev_p, R_AGC1R);
    RegGetOneRegister(Dev_p, R_AGC2O);
    RegGetOneRegister(Dev_p, R_RCR);
    RegGetOneRegister(Dev_p, R_MCR);

    fm=CalcMasterClkFrequency(Dev_p, FieldGetVal(Dev_p, STDBY),
                              FieldGetVal(Dev_p, DIRCLK),
                              FieldGetVal(Dev_p, K),
                              FieldGetVal(Dev_p, M),
                              FieldGetVal(Dev_p, P));

    return CalcAGC2TimeConstant(FieldGetVal(Dev_p, AGC2COEF),
                                FieldGetVal(Dev_p, 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(STV0299_ControlBlock_t *Dev_p)
{
    int locked;
    long TimingFreq;   /* long to match type of return used  (CalcSymbolRate) --SFS */

    unsigned char Sr[3];

    locked=RegGetField(Dev_p, TLIR);

    if(locked>42)
    {
        if(locked>48)
            locked = 1;
        else
        {
            RegGetRegisters(Dev_p, R_SFRH,3);	/*	Read symbol rate registers	*/

            Sr[0] = FieldGetVal(Dev_p, SYMB_FREQH);	/*	Save symbol rate registers	*/
            Sr[1] = FieldGetVal(Dev_p, SYMB_FREQM);
            Sr[2] = FieldGetVal(Dev_p, SYMB_FREQL);

            TimingFreq = CalcSymbolRate(Dev_p, Sr[0],Sr[1],Sr[2]); /* cast to eliminate compiler warning --SFS */
            RegSetSymbolRate(Dev_p, (TimingFreq-(TimingFreq/100)));

            if(RegGetField(Dev_p, TLIR) < locked)
                locked = 1;
            else
                locked = 0;

            FieldSetVal(Dev_p, SYMB_FREQH,Sr[0]);
            FieldSetVal(Dev_p, SYMB_FREQM,Sr[1]);
            FieldSetVal(Dev_p, SYMB_FREQL,Sr[2]);

            RegSetRegisters(Dev_p, R_SFRH,3);	/*	Write symbol rate registers	*/
        }
    }
    else locked = 0;

    return locked;
}

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

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


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

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

FLAG RegGetTrigger(STV0299_ControlBlock_t *Dev_p)
{
    return(Dev_p->RegTrigger);
}

void RegSetTrigger(STV0299_ControlBlock_t *Dev_p, FLAG _Trigger)
{
    Dev_p->RegTrigger = _Trigger;
}

/* End of reg0299.c */