reg0299.c

st7710的tuner标准驱动

    Compute damping factor for timing loop
Parameters:
    m2		->	AGC2 reference level
    alphatmg->	Alpha timing
    betatmg ->	Beta timing
Return Value:
    Timing damping factor (*1000)
---------------------------------------------------------------------------- */
long Reg0299_CalcTimingDampingFactor(int m2, int alphatmg, int betatmg)
{
    long DampFact=0;

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

    return DampFact;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetTimingDampingFactor()

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

Return Value:
    Timing damping factor
---------------------------------------------------------------------------- */
long Reg0299_RegGetTimingDampingFactor(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{ U8 RTCTemp;
    
    RTCTemp=STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_RTC);

    return Reg0299_CalcTimingDampingFactor( STTUNER_IOREG_GetField(DeviceMap,IOHandle, F0299_AGC2_REF),
                                            STTUNER_IOREG_FieldExtractVal(RTCTemp,IOHandle, F0299_ALPHA_TMG),
                                            STTUNER_IOREG_FieldExtractVal(RTCTemp,IOHandle, F0299_BETA_TMG) );
}


/* ----------------------------------------------------------------------------
Name: Reg0299_CalcSymbolRate()

Description:
    Compute symbol frequency
Parameters:
    Hbyte	->	High order byte
    Mbyte	->	Mid byte
    Lbyte	->	Low order byte
Return Value:
    Symbol frequency
---------------------------------------------------------------------------- */
long Reg0299_CalcSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, int Hbyte, int Mbyte, int Lbyte)
{
    long Ltmp, Ltmp2;
    long Mclk;

    Mclk  =  Reg0299_RegGetMasterFreq(DeviceMap, IOHandle) / 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;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegSetSymbolRate()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
long Reg0299_RegSetSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, long SymbolRate)
{
    unsigned long Result;
    long MasterClock;
    U8 freq[3];

    /*
     ** 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 = Reg0299_RegGetMasterFreq(DeviceMap, IOHandle);
    Result = STTUNER_Util_BinaryFloatDiv(SymbolRate, MasterClock, 20);
    freq[0]=(Result>>12) & 0xFF;
    freq[1]=(Result>>4)  & 0xFF;
    freq[2]= (Result & 0x0F)<<4;
    STTUNER_IOREG_SetContigousRegisters(DeviceMap, IOHandle, R0299_SFRH, freq,3);

    return(SymbolRate);
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetSymbolRate()

Description:
    Return the symbol rate
Parameters:

Return Value:
    Symbol rate
---------------------------------------------------------------------------- */
long Reg0299_RegGetSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
	U8 sfrh[2];
    STTUNER_IOREG_GetContigousRegisters(DeviceMap, IOHandle, R0299_SFRH, 3,sfrh);

    return Reg0299_CalcSymbolRate( DeviceMap, IOHandle, sfrh[0],sfrh[1],(sfrh[2]>>4));
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegIncrSymbolRate()

Description:
    add a correction to the symbol rate
Parameters:

Return Value:
    New symbol rate
---------------------------------------------------------------------------- */
long Reg0299_RegIncrSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, long correction)
{
    long Ltmp	  ;
    U8 sfrh[3],freq[3];

    STTUNER_IOREG_GetContigousRegisters(DeviceMap, IOHandle, R0299_SFRH, 3,sfrh);

    Ltmp  = (long)sfrh[0]<< 12;
    Ltmp += (long)sfrh[1] <<  4;
    Ltmp += (long)(sfrh[2] >>  4);


    Ltmp += correction;

    freq[0]= (int)((Ltmp>>12) & 0xFF);   /* cast to eliminate compiler warning --SFS */
    freq[1]=(int)((Ltmp>>4)  & 0xFF);    /* cast to eliminate compiler warning --SFS */
    freq[2]=(int)((Ltmp&0x0F)<<4);
    /*STTUNER_IOREG_SetFieldVal(DeviceMap, F0299_SYMB_FREQL,(int)( Ltmp      & 0x0F), (freq+2)); */        /* cast to eliminate compiler warning --SFS */
    STTUNER_IOREG_SetContigousRegisters(DeviceMap, IOHandle,  R0299_SFRH, freq,3);

    return	Reg0299_RegGetSymbolRate(DeviceMap, IOHandle);
}


/* ----------------------------------------------------------------------------
Name: Reg0299_CalcAGC1TimeConstant()

Description:
    compute AGC1 time constant
Parameters:
    m1			->	AGC1 reference value
    fm			->	Master clock frequency (MHz)
    betaagc1	->	BeatAgc1
Return Value:
    AGC1 time constant (us)
---------------------------------------------------------------------------- */
long Reg0299_CalcAGC1TimeConstant(int m1, long fm, int betaagc1)
{
    long  Tagc1;

    if((m1==0)||(fm==0))
        return(0);

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

    return Tagc1;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetAGC1TimeConstant()

Description:
    compute AGC1 time constant
Parameters:
    m1			->	AGC1 reference value
    fm			->	Master clock frequency (MHz)
    betaagc1	->	BeatAgc1
Return Value:
    AGC1 time constant
---------------------------------------------------------------------------- */
long Reg0299_RegGetAGC1TimeConstant(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
    long fm;
    U8 rcr[2];

    /*STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_AGC1C);
    STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_AGC1R);*/
    STTUNER_IOREG_GetContigousRegisters(DeviceMap,  IOHandle, R0299_RCR, 2,rcr);	/*	RCR, MCR */

    fm = Reg0299_CalcMasterClkFrequency( DeviceMap, STTUNER_IOREG_FieldExtractVal(rcr[1], F0299_STDBY),
                                                    STTUNER_IOREG_FieldExtractVal(rcr[0], F0299_DIRCLK),
                                                    STTUNER_IOREG_FieldExtractVal(rcr[0], F0299_K),
                                                    STTUNER_IOREG_FieldExtractVal(rcr[0], F0299_M),
                                                    STTUNER_IOREG_FieldExtractVal(rcr[1], F0299_P) );

    return Reg0299_CalcAGC1TimeConstant( STTUNER_IOREG_GetField(DeviceMap,IOHandle, F0299_AGC1_REF),
                                         fm,
                                         STTUNER_IOREG_GetField(DeviceMap,IOHandle, F0299_BETA_AGC1) );
}


/* ----------------------------------------------------------------------------
Name: Reg0299_CalcAGC2TimeConstant()

Description:
    compute AGC2 time constant
Parameters:
    agc2coef	->	AGC2 coeficient
    m1			->	AGC1 reference value
    fm			->	Master clock frequency (MHz)
Return Value:
    AGC2 time constant (ns)
---------------------------------------------------------------------------- */
long Reg0299_CalcAGC2TimeConstant(long agc2coef, long m1, long fm)
{
    long	BetaAgc2,
    Tagc2=0;

    if( (m1 != 0) && (fm != 0) )
    {
        BetaAgc2 = STTUNER_Util_PowOf2((int)(agc2coef-1)*2);  /* cast to eliminate compiler warning --SFS */

        Tagc2=60000*10000;
        Tagc2/=(fm/1000);
        Tagc2/=m1*BetaAgc2;
        Tagc2*=100;
    }

    return Tagc2;
}


/* ----------------------------------------------------------------------------
Name: Reg0299_RegGetAGC2TimeConstant()

Description:
    read registers then compute AGC2 time constant
Parameters:
Return Value:
    AGC2 time constant
---------------------------------------------------------------------------- */
long Reg0299_RegGetAGC2TimeConstant(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
    long fm;
    U8  RCRTemp,MCRTemp,AGC2OTemp,AGC1Temp;
    AGC1Temp = STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_AGC1R);
    AGC2OTemp = STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_AGC2O);
    RCRTemp = STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_RCR);
    MCRTemp = STTUNER_IOREG_GetRegister(DeviceMap, IOHandle, R0299_MCR);

    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));

    return Reg0299_CalcAGC2TimeConstant( STTUNER_IOREG_FieldExtractVal(AGC2OTemp, F0299_AGC2COEF),
                                         STTUNER_IOREG_FieldExtractVal(AGC1Temp, F0299_AGC1_REF),
                                         fm );
}


/*=====================================================
 **=====================================================
 **||||                                             ||||
 **||||           F22 GENERATION FACILITIES         ||||
 **||||                                             ||||
 **=====================================================
 **===================================================*/

void Reg0299_RegF22On(STTUNER_IOREG_DeviceMap_t *DeviceMap)
{
    /*RegSetField(F22OUTPUT, 1); */
}

void Reg0299_RegF22Off(STTUNER_IOREG_DeviceMap_t *DeviceMap)
{
    /*RegSetField(F22OUTPUT, 0);	*/
}


/*=====================================================
 **=====================================================
 **||||                                             ||||
 **||||           TRIGGER FACILITIES                ||||
 **||||                                             ||||
 **=====================================================
 **===================================================*/
/*
void Reg0299_RegTriggerOn(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
    if(DeviceMap->RegTrigger == IOREG_YES)*/
        /* I/O = 1 */
/*        STTUNER_IOREG_SetField(DeviceMap, IOHandle, F0299_DACMODE, 1);
}*/

/*
void Reg0299_RegTriggerOff(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
    if(DeviceMap->RegTrigger == IOREG_YES)*/
        /* I/O = 0 */
      /*  STTUNER_IOREG_SetField(DeviceMap, IOHandle, F0299_DACMODE, 0);
}
*/

/*STTUNER_IOREG_Flag_t Reg0299_RegGetTrigger(STTUNER_IOREG_DeviceMap_t *DeviceMap)
{
    return(DeviceMap->RegTrigger);
}


void Reg0299_RegSetTrigger(STTUNER_IOREG_DeviceMap_t *DeviceMap, STTUNER_IOREG_Flag_t Trigger)
{
    DeviceMap->RegTrigger = Trigger;
}
*/
/* End of reg0299.c */