reg0299.c

st7710的tuner标准驱动

    switch(function)
    {
        case 0:
            aclk = 0;
            break;

        case 1:
            if(value)
                aclk = Reg0299_CalcVCOFrequency(DeviceMap, k, m) / 8 / value;
            else
                aclk = Reg0299_CalcVCOFrequency(DeviceMap, k, m) / 8;
            break;

        default:
            factor = 8192L * STTUNER_Util_PowOf2(function - 2);
            aclk = Reg0299_CalcVCOFrequency(DeviceMap, k, m)/(long)factor/(32+(long)value); /* cast to eliminate compiler warning --SFS */
            break;
    }

    return(aclk);
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetAuxFreq()

Description:
    Read registers and compute Auxiliary clock frequency
Parameters:

Return Value:
    Auxiliary Clock frequency
---------------------------------------------------------------------------- */
long Reg0299_RegGetAuxFreq(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{ U8 RCRTemp;
    /*	Read registers	*/
    RCRTemp=STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_RCR);
   

    return Reg0299_CalcAuxClkFrequency( DeviceMap, STTUNER_IOREG_FieldExtractVal(RCRTemp, F0299_K),
                                                   STTUNER_IOREG_FieldExtractVal(RCRTemp, F0299_M),
                                                   STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_ACR));    /* Compute auxiliary clock freq */
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetErrorCount()

Description:

Parameters:

Return Value:

---------------------------------------------------------------------------- */
int Reg0299_RegGetErrorCount(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
	U8 errcnt[2];
    /* Obtain high and low bytes for error count register */
    STTUNER_IOREG_GetContigousRegisters(DeviceMap, IOHandle, R0299_ERRCNT_HIGH, 2,errcnt);

    return ( MAC0299_MAKEWORD(errcnt[0],errcnt[1]) );
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegSetErrorCount()

Description:

Parameters:

Return Value:

---------------------------------------------------------------------------- */
void Reg0299_RegSetErrorCount(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, int Value)
{
    STTUNER_IOREG_SetField(DeviceMap, IOHandle, F0299_ERRCNTMSB, MAC0299_MSB(Value));
    STTUNER_IOREG_SetField(DeviceMap, IOHandle, F0299_ERRCNTLSB, MAC0299_LSB(Value));
}


/* ----------------------------------------------------------------------------
Name: Reg0299_GetRollOff()

Description:
    Simple function whichs read the register 00h  bit bit1 and which sets
    corresponding Nyquist filter roll-off value.
Parameters:

Return Value:

---------------------------------------------------------------------------- */
int Reg0299_GetRollOff(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
    if ( STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_NYQUISTFILTER) == 1 )
        return 20;
    else
        return 35;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegSetRollOff()

Description:

Parameters:

Return Value:

---------------------------------------------------------------------------- */
void Reg0299_RegSetRollOff(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, int Value)
{
    if(Value == 35)
        STTUNER_IOREG_SetField(DeviceMap, IOHandle, F0299_NYQUISTFILTER, 0);
    else
        STTUNER_IOREG_SetField(DeviceMap, IOHandle, F0299_NYQUISTFILTER, 1);
}


/* ----------------------------------------------------------------------------
Name: Reg0299_CalcCarrierNaturalFrequency()

Description:
    Compute natural clock frequency for carrier loop

Parameters:
    m2		->	AGC2 reference level
    betacar ->	Beta carrier
    fm		->	Master clock frequency (MHz)
    fs		->	Symbol frequency (MHz)

Return Value:
    Carrier natural frequency (KHz)
---------------------------------------------------------------------------- */
long Reg0299_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)STTUNER_Util_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  = STTUNER_Util_LongSqrt(NatFreq)*(fm/1000)*7L;
        NatFreq /= 1000L;
    }

    return NatFreq;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetCarrierNaturalFrequency()

Description:
    Read registers and compute natural clock frequency for carrier loop
Parameters:

Return Value:
    Carrier natural frequency
---------------------------------------------------------------------------- */
long Reg0299_RegGetCarrierNaturalFrequency(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{   U8 RCRTemp,MCRTemp,AGC2OTemp,BCLCTemp,sfrh[3];
    long fm, fs;

RCRTemp =  STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_RCR);
MCRTemp =  STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_MCR);
    STTUNER_IOREG_GetContigousRegisters(DeviceMap, IOHandle, R0299_SFRH, 3,sfrh);    /* SFRH, SFRM, SFRL */

    fm = Reg0299_CalcMasterClkFrequency(DeviceMap, STTUNER_IOREG_FieldExtractVal(MCRTemp, F0299_STDBY),
                                                   STTUNER_IOREG_FieldExtractVal(RCRTemp, F0299_DIRCLK),
                                                   STTUNER_IOREG_FieldExtractVal(RCRTemp, F0299_K),
                                                   STTUNER_IOREG_FieldExtractVal(RCRTemp, F0299_M),
                                                   STTUNER_IOREG_FieldExtractVal(MCRTemp, F0299_P));

    fs = Reg0299_CalcSymbolRate(DeviceMap, IOHandle, sfrh[0],
                                                     sfrh[1],
                                                     STTUNER_IOREG_FieldExtractVal(sfrh[2], F0299_SYMB_FREQL));

    return Reg0299_CalcCarrierNaturalFrequency( STTUNER_IOREG_GetField(DeviceMap,IOHandle, F0299_AGC2_REF),
                                                STTUNER_IOREG_GetField(DeviceMap,IOHandle, F0299_BETA_CAR),
                                                fm,
                                                fs );
}


  

/* ----------------------------------------------------------------------------
Name: Reg0299_CalcCarrierDampingFactor()

Description:
    Compute damping factor for carrier loop
Parameters:
    m2		->	AGC2 reference level
    alphacar->	Alpha carrier
    betacar ->	Beta carrier
    fm		->	Master clock frequency
    fs		->	Symbol frequency

Return Value:
    Carrier damping factor
---------------------------------------------------------------------------- */
long Reg0299_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)*STTUNER_Util_PowOf2((int)b+14));     /* cast to eliminate compiler warning --SFS */
        betacar  = (int)((4+2*c+d)*STTUNER_Util_PowOf2((int)e));    /* cast to eliminate compiler warning --SFS */

        /*	Erreur d'arrondi lorsque Fs est faible	*/
        DampFact  = ((long)m2*fs/betacar*100/fm);
        DampFact  = STTUNER_Util_LongSqrt(DampFact)*alphacar/10;
        DampFact /= 1000L; /*	=1000000 / 1000	*/
        DampFact *= 22L;
    }

    return DampFact;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetCarrierDampingFactor()

Description:
    Read registers and compute damping factor for carrier loop
Parameters:

Return Value:
    Carrier damping factor
---------------------------------------------------------------------------- */
long Reg0299_RegGetCarrierDampingFactor(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
    long fm, fs;
    U8 rcr[2],aclc[2],sfrh[3];

    STTUNER_IOREG_GetContigousRegisters(DeviceMap, IOHandle, R0299_RCR,  2,rcr);    /* RCR, MCR */
    STTUNER_IOREG_GetRegister(DeviceMap,           IOHandle, R0299_AGC2O);
    STTUNER_IOREG_GetContigousRegisters(DeviceMap, IOHandle, R0299_ACLC, 2,aclc);    /* ACLC, BCLC	*/
    STTUNER_IOREG_GetContigousRegisters(DeviceMap, IOHandle, R0299_SFRH, 3,sfrh);    /* SFRH, SFRM, SFRL */

    fm = Reg0299_CalcMasterClkFrequency(DeviceMap, STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_STDBY),
                                                   STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_DIRCLK),
                                                   STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_K),
                                                   STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_M),
                                                   STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_P) );

    fs = Reg0299_CalcSymbolRate(DeviceMap, IOHandle, STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_SYMB_FREQH),
                                                     STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_SYMB_FREQM),
                                                     STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_SYMB_FREQL));

    return Reg0299_CalcCarrierDampingFactor( STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_AGC2_REF),
                                             STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_ALPHA_CAR),
                                             STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_BETA_CAR),
                                             fm,
                                             fs );
}


/* ----------------------------------------------------------------------------
Name: Reg0299_CalcTimingNaturalFrequency()

Description:
    Compute natural frequency for timing loop
Parameters:
    m2		->	AGC2 reference level
    betatmg ->	Beta timing
    fs		->	Symbol frequency (MHz)
Return Value:
    Timing natural frequency (MHz)
---------------------------------------------------------------------------- */
long Reg0299_CalcTimingNaturalFrequency(STTUNER_IOREG_DeviceMap_t *DeviceMap, int m2, int betatmg, long fs)
{
    long NatFreq=0;

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

    return NatFreq;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetTimingNaturalFrequency()

Description:
    Read registers and compute natural clock frequency for timing loop
Parameters:

Return Value:
    Timing natural frequency (MHz)
---------------------------------------------------------------------------- */
long Reg0299_RegGetTimingNaturalFrequency(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
    long fs;

  /*  STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_AGC2O);
    STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_RTC);
    STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_SFRH);
    STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_SFRM);
    STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_SFRL);*/

    fs = Reg0299_CalcSymbolRate( DeviceMap, IOHandle, STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_SYMB_FREQH),
                                                      STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_SYMB_FREQM),
                                                      STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_SYMB_FREQL) );

    return Reg0299_CalcTimingNaturalFrequency( DeviceMap, STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_AGC2_REF),
                                                          STTUNER_IOREG_GetField(DeviceMap, IOHandle, F0299_BETA_TMG),
                                                          fs );
}


/* ----------------------------------------------------------------------------
Name: Reg0299_CalcTimingDampingFactor()

Description: