/*****************************************************************************File Name   : driv0299.cDescription : STV0299 front-end driver routines.Copyright (C) 2000 STMicroelectronicsRevision 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;