reg0299.c

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

/*****************************************************
 **FUNCTION	::	RegGetVCOFreq
 **ACTION	::	Read registers and compute VCO frequency
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	VCO frequency
 *****************************************************/
long RegGetVCOFreq(STV0299_ControlBlock_t *Dev_p)
{
    /*	Read register	*/
    RegGetOneRegister(Dev_p, R_RCR);

    return CalcVCOFrequency(Dev_p, FieldGetVal(Dev_p, K),
                            FieldGetVal(Dev_p, M)); /*	compute VCO freq	*/
}

/*****************************************************
 **FUNCTION	::	CalcF22Frequency
 **ACTION	::	Compute F22 frequency
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	F22 frequency
 *****************************************************/
long CalcF22Frequency(STV0299_ControlBlock_t *Dev_p, int k,int m,int f22)
{
    return (f22!=0) ? (CalcVCOFrequency(Dev_p, k,m)/(128*(long)f22)) : 0;  /* cast to eliminate compiler warning --SFS */
}

/*****************************************************
 **FUNCTION	::	RegGetF22Freq
 **ACTION	::	Read registers and Compute F22 frequency
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	F22 frequency
 *****************************************************/
long RegGetF22Freq(STV0299_ControlBlock_t *Dev_p)
{
    /*	Read registers	*/
    RegGetOneRegister(Dev_p, R_RCR);
    RegGetOneRegister(Dev_p, R_F22FR);

    return CalcF22Frequency(Dev_p, FieldGetVal(Dev_p, K),
                            FieldGetVal(Dev_p, M),
                            FieldGetVal(Dev_p, F22FR));	/*	Compute F22 freq	*/
}


/*****************************************************
 **FUNCTION	::	CalcMasterClkFrequency
 **ACTION	::	Compute Master clock frequency
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Master Clock frequency
 *****************************************************/
long CalcMasterClkFrequency(STV0299_ControlBlock_t *Dev_p, int stdby ,int dirclk ,int k ,int m, int p)
{
    long
            mclk;

    if(stdby)
        mclk=0;
    else if(dirclk)
        mclk=RegGetExtClk(Dev_p);
    else
        mclk=CalcVCOFrequency(Dev_p, k,m)/((2+((long)p%2))*PowOf2((p/2)+1));  /* cast to eliminate compiler warning --SFS */

    return mclk;
}

/*****************************************************
 **FUNCTION	::	RegGetMasterFreq
 **ACTION	::	Read registers and compute Master clock frequency
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Master Clock frequency
 *****************************************************/
long RegGetMasterFreq(STV0299_ControlBlock_t *Dev_p)
{
    /*	Read registers	*/
    RegGetOneRegister(Dev_p, R_RCR);
    RegGetOneRegister(Dev_p, R_MCR);

    return CalcMasterClkFrequency(Dev_p, FieldGetVal(Dev_p, STDBY),
                                  FieldGetVal(Dev_p, DIRCLK),
                                  FieldGetVal(Dev_p, K),
                                  FieldGetVal(Dev_p, M),
                                  FieldGetVal(Dev_p, 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(STV0299_ControlBlock_t *Dev_p)
{
    /*	Read registers	*/
    RegGetRegisters(Dev_p, R_CFRM,2);

    return CalcDerotatorFrequency(FieldGetVal(Dev_p, DEROTATORFREQUENCYMSB),
                                  FieldGetVal(Dev_p, DEROTATORFREQUENCYLSB),
                                  RegGetMasterFreq(Dev_p));
}

/*****************************************************
 **FUNCTION	::	CalcAuxClkFrequency
 **ACTION	::	Compute Auxiliary clock frequency
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Auxiliary Clock frequency
 *****************************************************/
long CalcAuxClkFrequency(STV0299_ControlBlock_t *Dev_p, 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(Dev_p, k,m)/8/value;
            else
                aclk = CalcVCOFrequency(Dev_p, k,m)/8;
            break;

        default:
            factor = 8192L*PowOf2(function-2);
            aclk = CalcVCOFrequency(Dev_p, k,m)/(long)factor/(32+(long)value); /* cast to eliminate compiler warning --SFS */
            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(STV0299_ControlBlock_t *Dev_p)
{
    /*	Read registers	*/
    RegGetOneRegister(Dev_p, R_RCR);
    RegGetOneRegister(Dev_p, R_ACR);

    return CalcAuxClkFrequency(Dev_p, FieldGetVal(Dev_p, K),
                               FieldGetVal(Dev_p, M),
                               FieldGetVal(Dev_p, ACR));	/*	Compute auxiliary clock freq	*/
}


int RegGetErrorCount(STV0299_ControlBlock_t *Dev_p)
{
    /* Obtain high and low bytes for error count register */
    RegGetRegisters(Dev_p, R_ERRCNT_HIGH, 2);

    return (MAKEWORD(FieldGetVal(Dev_p, ERRCNTMSB),
                     FieldGetVal(Dev_p, ERRCNTLSB)));
}

void RegSetErrorCount(STV0299_ControlBlock_t *Dev_p, int Value)
{
    RegSetField(Dev_p, ERRCNTMSB,MSB(Value));
    RegSetField(Dev_p, 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(STV0299_ControlBlock_t *Dev_p)
{
    if ( RegGetField(Dev_p, NYQUISTFILTER)==1 )
        return 20;
    else
        return 35;
}

/*
 **
 */
void RegSetRollOff(STV0299_ControlBlock_t *Dev_p, int _Value)
{
    if(_Value == 35)
        RegSetField(Dev_p, NYQUISTFILTER,0);
    else
        RegSetField(Dev_p, NYQUISTFILTER,1);
}

/*****************************************************
 **FUNCTION	::	CalcCarrierNaturalFrequency
 **ACTION	::	Compute natural clock frequency for carrier loop
 **PARAMS IN	::	m2		->	AGC2 reference level
 **				betacar ->	Beta carrier
 **				fm		->	Master clock frequency (MHz)
 **				fs		->	Symbol frequency (MHz)
 **PARAMS OUT::	NONE
 **RETURN	::	Carrier natural frequency (KHz)
 *****************************************************/
long  CalcCarrierNaturalFrequency(int m2 ,int betacar ,long fm ,long fs)
{
    long NatFreq=0;
    long c,d,e;

    if(fm>0L)
    {
        c= ((long)betacar & 0x02)>>1;  /* cast to eliminate compiler warning --SFS */
        d= (long)betacar & 0x01;       /* cast to eliminate compiler warning --SFS */
        e= ((long)betacar & 0x3C)>>2;  /* cast to eliminate compiler warning --SFS */
        betacar= (int)(4+2*c+d)*(int)PowOf2((int)e); /* cast to eliminate compiler warning --SFS */

        NatFreq= (long)((long)m2*betacar);  /* cast to eliminate compiler warning --SFS */
        NatFreq*=fs/(fm/1000);
        NatFreq/=1000;
        NatFreq=LongSqrt(NatFreq)*(fm/1000)*7L;
        NatFreq/=1000L;
    }

    return NatFreq;
}

/*****************************************************
 **FUNCTION	::	RegGetCarrierNaturalFrequency
 **ACTION	::	Read registers and compute natural clock frequency for carrier loop
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Carrier natural frequency
 *****************************************************/
long RegGetCarrierNaturalFreq(STV0299_ControlBlock_t *Dev_p)
{
    long fm,fs;

    RegGetOneRegister(Dev_p, R_RCR);
    RegGetOneRegister(Dev_p, R_MCR);
    RegGetOneRegister(Dev_p, R_AGC2O);
    RegGetOneRegister(Dev_p, R_BCLC);
    RegGetOneRegister(Dev_p, R_SFRH);
    RegGetOneRegister(Dev_p, R_SFRM);
    RegGetOneRegister(Dev_p, R_SFRL);

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

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

    return CalcCarrierNaturalFrequency(FieldGetVal(Dev_p, AGC2_REF)
                                       ,FieldGetVal(Dev_p, BETA_CAR)
                                       ,fm
                                       ,fs);
}

/*****************************************************
 **FUNCTION	::	CalcCarrierDampingFactor
 **ACTION	::	Compute damping factor for carrier loop
 **PARAMS IN	::	m2		->	AGC2 reference level
 **				alphacar->	Alpha carrier
 **				betacar ->	Beta carrier
 **				fm		->	Master clock frequency
 **				fs		->	Symbol frequency
 **PARAMS OUT::	NONE
 **RETURN	::	Carrier damping factor
 *****************************************************/
long CalcCarrierDampingFactor(int m2,int alphacar,int betacar, long fm, long fs)
{
    /* the damping factor can be below 1. So, in order to have
     ** an accurate integer value, the result will be 1000*damping factor	*/

    long DampFact=0;
    long a,b,c,d,e;

    if(fm>0)
    {
        a= (long)alphacar & 0x01;        /* cast to eliminate compiler warning --SFS */
        b= ((long)alphacar & 0x0E)>>1;   /* cast to eliminate compiler warning --SFS */
        c= ((long)betacar & 0x02)>>1;    /* cast to eliminate compiler warning --SFS */
        d= (long)betacar & 0x01;         /* cast to eliminate compiler warning --SFS */
        e= ((long)betacar & 0x3C)>>2;    /* cast to eliminate compiler warning --SFS */
        alphacar= (int)((2+a)*PowOf2((int)b+14)); /* cast to eliminate compiler warning --SFS */
        betacar= (int)((4+2*c+d)*PowOf2((int)e));  /* cast to eliminate compiler warning --SFS */
        /*	Erreur d'arrondi lorsque Fs est faible	*/
        DampFact=((long)m2*fs/betacar*100/fm);
        DampFact=LongSqrt(DampFact)*alphacar/10;
        DampFact/=1000L; /*	=1000000 / 1000	*/
        DampFact*=22L;
    }

    return DampFact;
}

/*****************************************************
 **FUNCTION	::	RegGetCarrierDampingFactor
 **ACTION	::	Read registers and compute damping factor for carrier loop
 **PARAMS IN	::	NONE
 **PARAMS OUT::	NONE
 **RETURN	::	Carrier damping factor
 *****************************************************/
long RegGetCarrierDampingFactor(STV0299_ControlBlock_t *Dev_p)
{
    long fm,fs;

    RegGetRegisters(Dev_p, R_RCR,2);	/*	RCR,MCR	*/
    RegGetOneRegister(Dev_p, R_AGC2O);
    RegGetRegisters(Dev_p, R_ACLC,2);  /*	ACLC,BCLC	*/
    RegGetRegisters(Dev_p, R_SFRH,3);  /*	SFRH,SFRM,SFRL	*/

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

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

    return CalcCarrierDampingFactor(FieldGetVal(Dev_p, AGC2_REF),
                                    FieldGetVal(Dev_p, ALPHA_CAR),
                                    FieldGetVal(Dev_p, BETA_CAR),
                                    fm,
                                    fs);
}


/*****************************************************
 **FUNCTION	::	CalcTimingNaturalFrequency
 **ACTION	::	Compute natural frequency for timing loop
 **PARAMS IN	::	m2		->	AGC2 reference level
 **				betatmg ->	Beta timing
 **				fs		->	Symbol frequency (MHz)
 **PARAMS OUT::	NONE
 **RETURN	::	Timing natural frequency (MHz)
 *****************************************************/
long CalcTimingNaturalFrequency(STV0299_ControlBlock_t *Dev_p, int m2, int betatmg,long fs)
{
    long NatFreq=0;

    if(betatmg >= 0)
    {
        NatFreq=LongSqrt((long)m2*PowOf2(betatmg));
        NatFreq*=(fs/1000000L);
        NatFreq*=52;
        NatFreq/=10;
    }

    return NatFreq;
}