driv0299.c

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

/*****************************************************************************
File Name   : driv0299.c

Description : STV0299 front-end driver routines.

Copyright (C) 2000 STMicroelectronics

Revision History    :

    04/02/00        Code based on original implementation by CBB.

    21/03/00        Received code modifications that eliminate compiler
                    warnings.

                    Added defensive check to Mclk == 0 during parameter
                    initialization routine to avoid potential divide by
                    zero exceptions.

Reference           :

*****************************************************************************/

#include <stdio.h>                      /* C libs */
#include <stdlib.h>
#include <string.h>

#include "stddefs.h"                    /* STAPI common includes */

#include "stv299.h"                     /* Local includes */
#include "driv0299.h"
#include "reg0299.h"

#define INTERPOLATE( LutLow, LutHigh, RealLow, RealHigh, Real) \
    (LutLow + (((Real - RealLow) * (LutHigh - LutLow)) / \
               (RealHigh - RealLow)))

typedef struct
{
    S32 Real;
    S32 Lookup;
} LUT_t;

static const LUT_t BerLUT[] =
{
    { ((U16)-1), 200000 },
    { 9600, 160000 },
    { 9450, 120000 },                   /* 2 */
    { 9260, 97000 },                    /* 2.5 */
    { 9000, 82000 },                    /* 3 */
    { 8760, 73000 },                    /* 3.5 */
    { 8520, 61500 },                    /* 4 */
    { 8250, 51000 },                    /* 4.5 */
    { 7970, 42000 },                    /* 5 */
    { 7690, 34000 },                    /* 5.5 */
    { 7360, 26000 },                    /* 6 */
    { 7080, 20600 },                    /* 6.5 */
    { 6770, 15000 },                    /* 7 */
    { 6470, 11200 },                    /* 7.5 */
    { 6200, 8000 },                     /* 8 */
    { 5900, 5400 },                     /* 8.5 */
    { 5670, 3600 },                     /* 9 */
    { 5420, 2320 },                     /* 9.5 */
    { 5190, 1450 },                     /* 10 */
    { 4960, 840 },                      /* 10.5 */
    { 4740, 480 },                      /* 11 */
    { 4550, 225 },                      /* 11.5 */
    { 4360, 130 },                      /* 12 */
    { 4170, 60 },                       /* 12.5 */
    { 4010, 30 },                       /* 13 */
    { 3860, 12 },                       /* 13.5 */
    { 3710, 4 },                        /* 14 */
    { 3580, 1 },                        /* 14.5 */
    { 3440, 0 },                        /* 15 */
    { 0, 0 },
    { ((U32)-1), 0 }                    /* End */
};

static const LUT_t SignalNoiseLUT[] =
{
    { ((U16)-1), 0 },                   /* 1 */
    { 9600, 19 },                       /* 1.5 */
    { 9450, 22 },                       /* 2 */
    { 9260, 25 },                       /* 2.5 */
    { 9000, 28 },                       /* 3 */
    { 8760, 31 },                       /* 3.5 */
    { 8520, 34 },                       /* 4 */
    { 8250, 37 },                       /* 4.5 */
    { 7970, 40 },                       /* 5 */
    { 7690, 43 },                       /* 5.5 */
    { 7360, 46 },                       /* 6 */
    { 7080, 49 },                       /* 6.5 */
    { 6770, 52 },                       /* 7 */
    { 6470, 55 },                       /* 7.5 */
    { 6200, 58 },                       /* 8 */
    { 5900, 61 },                       /* 8.5 */
    { 5670, 64 },                       /* 9 */
    { 5420, 67 },                       /* 9.5 */
    { 5190, 70 },                       /* 10 */
    { 4960, 73 },                       /* 10.5 */
    { 4740, 76 },                       /* 11 */
    { 4550, 79 },                       /* 11.5 */
    { 4360, 82 },                       /* 12 */
    { 4170, 85 },                       /* 12.5 */
    { 4010, 88 },                       /* 13 */
    { 3860, 91 },                       /* 13.5 */
    { 3710, 94 },                       /* 14 */
    { 3580, 97 },                       /* 14.5 */
    { 3440, 100 },                      /* 15 */
    { 0, 100 },
    { ((U32)-1), 0 }                          /* End */
};

static const LUT_t AgcLUT[] =
{
    { 127, 255 },                       /* 0dBm */
    { 115, 215 },                       /* -20dBm */
    { 99,  205 },                       /* -25dBm */
    { 83, 195 },                        /* -30dBm */
    { 70, 185 },                        /* -35dBm */
    { 60, 175 },                        /* -40dBm */
    { 54, 165 },                        /* -45dBm */
    { 47, 155 },                        /* -50dBm */
    { 40, 145 },                        /* -55dBm */
    { 27, 135 },                        /* -60dBm */
    { 9, 125 },                         /* -65dBm */
    { -20, 115 },                       /* -70dBm */
    { -64, 105 },                       /* -75dBm */
    { -116, 95 },                       /* -80dBm */
    { -128, 92 },                       /* -81dBm */
    { -128, 92 },
    { ((U32)-1), 0 }                    /* End */
};

long PowOf2(int number);

/* Delay routine */
#define SystemWaitFor(x)                STV0299_Delay((x*1000))

/*****************************************************
--FUNCTION  ::    WaitTuner
--ACTION    ::    Wait for tuner locked
--PARAMS IN ::    TimeOut    ->    Maximum waiting time (in ms)
--PARAMS OUT::    NONE
--RETURN    ::    NONE
--***************************************************/
void WaitTuner(STV0299_ControlBlock_t *Dev_p, int TimeOut)
{
    int Time=0;
    BOOL TunerLocked = FALSE;

    while(!TunerLocked && (Time<TimeOut))
    {
        SystemWaitFor(1);
        TNR_IsTunerLocked(TNR_HANDLE(Dev_p), &TunerLocked);
        Time++;
    }
    Time--;
}

/****************************************************
--FUNCTION    ::    CheckAgc1
--ACTION    ::    Check agc1 value
--PARAMS IN    ::    pParams    ->    Pointer to SEARCHPARAMS structure
--PARAMS OUT::    pParams->State is modified
--RETURN    ::    NOAGC1 if AGC1=-128, AGC1SATURATION
--                if AGC1=127, AGC1OK otherwise
--**************************************************/
SIGNALTYPE CheckAgc1(STV0299_ControlBlock_t *Dev_p, SEARCHPARAMS *pParams)
{
    int AGC1Value;
    int Agc1Threshold = -128;

    AGC1Value = RegGetField(Dev_p, AGCINTEGRATORVALUE);

    if (AGC1Value == Agc1Threshold )
        pParams->State = NOAGC1;
    else if(AGC1Value == 127)
        pParams->State = AGC1SATURATION;
    else
        pParams->State = AGC1OK;

    return pParams->State;
}

/*****************************************************
--FUNCTION  ::    CheckTiming
--ACTION    ::    Check for timing locked
--PARAMS IN ::    pParams->Ttiming    =>    Time to wait for timing loop locked
--PARAMS OUT::    pParams->State        =>    result of the check
--RETURN    ::    NOTIMING if timing not locked, TIMINGOK otherwise
--***************************************************/
SIGNALTYPE CheckTiming(STV0299_ControlBlock_t *Dev_p, SEARCHPARAMS *pParams)
{
    int locked, timing;

    SystemWaitFor(pParams->Ttiming);
    locked=RegGetField(Dev_p, TLIR);
    timing=abs(RegGetField(Dev_p, RTF));
	if(locked >= 43)
	{
		if((locked > 48) && (timing >= 110))
			pParams->State = ANALOGCARRIER;
		else
			pParams->State = TIMINGOK;
	}
	else
		pParams->State = NOTIMING;

    return pParams->State;
}

/*****************************************************
--FUNCTION  ::    CenterTimingLoop
--ACTION    ::    Timing loop centring
--PARAMS IN ::    SymbolRate    ->    Current symbol rate value
--                MasterClock    ->    Current master clock frequency
--PARAMS OUT::    NONE
--RETURN    ::    New symbol rate
--***************************************************/
long CenterTimingLoop(STV0299_ControlBlock_t *Dev_p, long SymbolRate, long MasterClock)
{
    long Correction    ;
    long NewSymbolRate;

    /*    Read register    */
    RegGetField(Dev_p, RTF);

    /*    Centring the timing loop    */
    Correction    = (RegGetField(Dev_p, RTF)*(SymbolRate/8))/(MasterClock/2) ;
    /*    rounding    */
    Correction = (Correction >= 0) ? (Correction + 1)/2 : (Correction - 1)/2 ;
    NewSymbolRate = RegIncrSymbolRate(Dev_p, Correction) ;

    return NewSymbolRate;
}

/*****************************************************
--FUNCTION  ::    CheckAgc2
--ACTION    ::    Check agc2 value
--PARAMS IN ::    NbSample    ->    Number of samples
--PARAMS OUT::    Agc2Value    ->    Mean of Agc2 values
--RETURN    ::    NOAGC2 if AGC2 =0 or AGC2 = 32767, AGC2OK otherwise
--***************************************************/
SIGNALTYPE CheckAgc2(STV0299_ControlBlock_t *Dev_p, int NbSample,long *Agc2Value)
{
    int        Agc2Threshold =    0,i;
    long    Agc2Limit     = 32767*(long)NbSample ;  /* cast added to eliminate compiler warning --SFS */
    SIGNALTYPE Agc2Level;

    for (i=0; i < NbSample ; i++)
    {
        SystemWaitFor( 1 );                /*    1ms delay: settling time    */
        RegGetRegisters(Dev_p, R_AGC2I1,2);    /*    Read AGC2I1 and AGC2I2 registers    */

	 /* use int cast below to eliminate compile warning;  why does this work??? (I would think it should be caste to long) --SFS */
        *Agc2Value += (int)((FieldGetVal(Dev_p, AGC2INTEGRATORMSB)<<8) + FieldGetVal(Dev_p, AGC2INTEGRATORLSB));
    }

    if ( ( *Agc2Value > Agc2Threshold ) && ( *Agc2Value < Agc2Limit ) )
    {
        Agc2Level =    AGC2OK;
        *Agc2Value = *Agc2Value / NbSample;
    }
    else
    {
        Agc2Level = NOAGC2;
        *Agc2Value = 0;
    }

    return Agc2Level;
}



/*****************************************************
--FUNCTION  ::    CheckCarrier
--ACTION    ::    Check for carrier founded
--PARAMS IN ::    pParams        =>    Pointer to SEARCHPARAMS structure
--PARAMS OUT::    pParams->State    => Result of the check
--RETURN    ::    NOCARRIER carrier not founded, CARRIEROK otherwise
--***************************************************/
SIGNALTYPE CheckCarrier(STV0299_ControlBlock_t *Dev_p, SEARCHPARAMS *pParams)
{
    SystemWaitFor(pParams->Tderot);                        /*    wait for derotator ok    */
    RegSetField(Dev_p, CFD_ALGO,0);

    if (RegGetField(Dev_p, CF))
        pParams->State = CARRIEROK;
    else
        pParams->State = NOCARRIER;

    return pParams->State;
}

/*****************************************************
--FUNCTION  ::    CarrierWidth
--ACTION    ::    Compute the width of the carrier
--PARAMS IN ::    SymbolRate    ->    Symbol rate of the carrier (Kbauds or Mbauds)
--                RollOff        ->    Rolloff * 100
--PARAMS OUT::    NONE
--RETURN    ::    Width of the carrier (KHz or MHz)
--***************************************************/
long CarrierWidth(long SymbolRate, long RollOff)
{
    return (SymbolRate  + (SymbolRate*RollOff)/100);
}


/*****************************************************
--FUNCTION  ::    CheckData
--ACTION    ::    Check for data founded
--PARAMS IN ::    pParams        =>    Pointer to SEARCHPARAMS structure
--PARAMS OUT::    pParams->State    => Result of the check
--RETURN    ::    NODATA data not founded, DATAOK otherwise
--***************************************************/
SIGNALTYPE CheckData(STV0299_ControlBlock_t *Dev_p, SEARCHPARAMS *pParams)
{
	printf("\npParams->Tdata=%d\n",pParams->Tdata ) ;
    SystemWaitFor(pParams->Tdata);                    /*    Wait for data    */

    if (RegGetField(Dev_p, LK))
        pParams->State = DATAOK;
    else
        pParams->State = NODATA;

    return pParams->State;
}

/*****************************************************
--FUNCTION  ::    IQInvertion
--ACTION    ::    Invert I and Q
--PARAMS IN ::    NONE
--PARAMS OUT::    NONE
--RETURN    ::    NONE
--***************************************************/
void IQInvertion(STV0299_ControlBlock_t *Dev_p)
{
    RegSetField(Dev_p, IQ,0x01 & (~RegGetField(Dev_p, IQ)));    /* inverting the I/Q configuration */
}

/*****************************************************
--FUNCTION  ::    CalcTimingTimeConstant
--ACTION    ::    Compute the amount of time needed by the timing loop to lock
--PARAMS IN ::    SymbolRate    ->    symbol rate value
--PARAMS OUT::    NONE
--RETURN    ::    Timing loop time constant (ms)
--***************************************************/
long CalcTimingTimeConstant(long SymbolRate)
{
    return (200000/(SymbolRate/1000));
}

/*****************************************************
--FUNCTION  ::    CalcDerotTimeConstant
--ACTION    ::    Compute the amount of time needed by the Derotator to lock
--PARAMS IN ::    SymbolRate    ->    symbol rate value
--PARAMS OUT::    NONE
--RETURN    ::    Derotator time constant (ms)
--***************************************************/
long CalcDerotTimeConstant(long SymbolRate)
{
    return (10000/(SymbolRate/1000));
}

/*****************************************************
--FUNCTION  ::    CalcDataTimeConstant
--ACTION    ::    Compute the amount of time needed to capture data
--PARAMS IN ::    Er        ->    Viterbi rror rate
--                Sn        ->  viterbi averaging period
--                To        ->  viterbi time out
--                Hy        ->    viterbi hysteresis
--                SymbolRate    ->    symbol rate value
--PARAMS OUT::    NONE
--RETURN    ::    Data time constant
--***************************************************/
long CalcDataTimeConstant(int Er, int Sn,int To,int Hy,long SymbolRate)
{
    long    Tviterbi = 0,
    TimeOut    =0,
    THysteresis    = 0,
    PhaseNumber[5] = {1,3,2,6,8},
    averaging[4] = {1024L,4096L,16384L,65536L},
    InnerCode = 1000,
    HigherRate = 1000;