hamaro_sdc.c

QPSK Tuner details, for conexant chipset.

/* hamaro_sts.c */
/*+++ *******************************************************************\
*
*  Abstract:
*
*       Hamaro Scan-the-sky Main FSM implementation.
*
*  Created: 07/15/2005
*
*
*  Copyright and Disclaimer: 
*  
*     --------------------------------------------------------------- 
*     This software is provided "AS IS" without warranty of any kind, 
*     either expressed or implied, including but not limited to the 
*     implied warranties of noninfringement, merchantability and/or  
*     fitness for a particular purpose.
*     --------------------------------------------------------------- 
*     
*   Author: Amar Puttur
*
*   Module Revision Id:
*
*       $Header:hamaro_sts.c, 1, 7/15/2005 6:49:57 PM, Amarnath Puttur$
*
*     Copyright (c) 2005 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/
#include "hamaro_sts.h"

#if HAMARO_SCAN_THE_SKY

#include "hamaro_binsrch.h"
#include "hamaro_srbin.h"
#include "hamaro_pwrscan.h"

#include "hamaro_bcd.h"

#include "sdc_sts.h"




#if HAMARO_WIN_DEBUG

#define  STSDBG_WR_INT_LN(str, val)         (WINDBG_WriteIntegerLn((char*)(str), val))
#define  STSDBG_WR_INT(str, val)            (WINDBG_WriteInteger((char*)(str), val))
#define  STSDBG_WR_HEX(str, val)            (WINDBG_WriteHex((char*)(str), val))
#define  STSDBG_WR_UNSIGNED_LN(str, val)    (WINDBG_WriteUnsignedLn((char*)(str), val))
#define  STSDBG_WR_UNSIGNED(str, val)       (WINDBG_WriteUnsigned((char*)(str), val))
#define  STSDBG_WR_STR(str, nl)             (WINDBG_WriteString((char*)(str), nl))
#define  STSDBG_WR_ELAPSED_TIME()           (WINDBG_FileWriteDuration())
#define  STSDBG_START_TIMER()               (WINDBG_SetTimer()) /* used for time measurements */

#else  // HAMARO_WIN_DEBUG

#define  STSDBG_WR_INT_LN(str, val)         /* Expands to nothing */ 
#define  STSDBG_WR_INT(str, val)            /* Expands to nothing */ 
#define  STSDBG_WR_UNSIGNED_LN(str, val)    /* Expands to nothing */ 
#define  STSDBG_WR_UNSIGNED(str, val)       /* Expands to nothing */ 
#define  STSDBG_WR_STR(str, nl)             /* Expands to nothing */ 
#define  STSDBG_WR_ELAPSED_TIME()           /* Expands to nothing */
#define  STSDBG_START_TIMER()               /* Expands to nothing */

#endif /* HAMARO_WIN_DEBUG */





extern TP_CANDIDATE g_tp_data0[];
extern TP_CANDIDATE g_tp_data1[];
#include "trace.h"
#define TRACE_FLAG  (TRACE_LEVEL_ALWAYS|TRACE_ALL|TRACE_NO_TIMESTAMP)

#include <stdlib.h>                    /* ANSI Standard */

#define  STS_TEST_DO_REG_PROGRAMMING        1

unsigned long sts_fsm_coding = 0; 

/* Instantiate the FSM object(s) */
FSM sts_fsm = {&sts_fsm_coding, 0x0000000F, 0, 0, 0, 0};            

static HAMARO_STSDATA    hamaro_sts_data;
static HAMARO_STS_STATUS hamaro_sts_status;

/*static*/ HAMARO_STS_POWER_SPECTRUM_DATA  *s_power_spectrum_data_base;
#define s_power_spectrum_data_base HWBUF_DEC_BUF0_ADDR
#define s_power_spectrum_data  (*(HAMARO_STS_POWER_SPECTRUM_DATA *)s_power_spectrum_data_base)

static HAMARO_STS_CHANNEL_INFO s_sts_channel_info[STS_MAX_SCAN_CHANNELS];

extern HAMARO_PWRSCAN_BUFFER_INFO s_pwrscan_buffer_info[STS_MAX_NUM_OF_SCAN_SEGMENTS];
static char s_pwrscan_buffer_info_delta[STS_MAX_NUM_OF_SCAN_SEGMENTS];

static unsigned short s_channel_info_index = 0;
static unsigned long  s_abs_left_inflection_point_hz, s_abs_right_inflection_point_hz;
static BOOL s_abort = False;

//static HAMARO_STS_CURVATURE_POINTS* p_find_fall_range_curvature;
//static HAMARO_STS_CURVATURE_POINTS* p_find_rise_range_curvature;
static unsigned int s_counts=0;
static unsigned short s_mean=0;
static unsigned short s_current_tp_index=1;
static TP_CANDIDATE *s_current_sd=0;

/* Added for fine scan */
int FineScanTpNo = 0;
signed char FineScanAagc =0;

static void STS_Cleanup();
static BOOL 
STS_StartSRBinning();

/* Function prototypes */
/* reset state */
static void   STS_ResetEnter();
static BOOL   STS_Reset2PowerScanCriterion();
static STATE* STS_Reset2PowerScan();

/* power scan state */
static void   STS_PowerScanEnter();
static BOOL   STS_PowerScan2BinarySearchCriterion();
static STATE* STS_PowerScan2BinarySearch();
static BOOL   STS_PowerScan2ResetCriterion();
static STATE* STS_PowerScan2Reset();
static BOOL   STS_PowerScan2CompleteCriterion();
static STATE* STS_PowerScan2Complete();

/* binary search state */
static void   STS_BinarySearchEnter();
static BOOL   STS_BinarySearch2ReadyCriterion();
static STATE* STS_BinarySearch2Ready();
static BOOL   STS_BinarySearch2BinarySearchCriterion();
static STATE* STS_BinarySearch2BinarySearch();

/* rescan state */
static void   STS_RescanEnter();
static BOOL   STS_Rescan2ResetCriterion();
static STATE* STS_Rescan2Reset();

/* ready state */
static void   STS_ReadyEnter();
static BOOL   STS_Ready2BinarySearchCriterion();
static STATE* STS_Ready2BinarySearch();
static BOOL   STS_Ready2SRBinCriterion();
static STATE* STS_Ready2SRBin();

/* SR binning state (channel extraction) */
static void   STS_SRBinEnter();
static BOOL   STS_SRBin2CompleteState();
static STATE* STS_SRBin2Complete();
static void   STS_SRBin();

/* complete state */
static void   STS_CompleteEnter();

/*****************************************************************************/
/*                              State tables                                 */
/*****************************************************************************/
STATE sts_reset_state = /* MAIN STS FSM, RESET state */
{
    STS_ResetEnter, /* Entry task */
    {
        {STS_Reset2PowerScanCriterion,  STS_Reset2PowerScan}, 
        {0, 0}      /* End of Criterion/Exit task */
    },
    0,              /* Regular task (none) */
    0,              /* no counter */
    STS_RESET_STATE /* state code  */
};


STATE sts_pwrscan_state = /* MAIN STS FSM, POWER SCAN state */
{
    STS_PowerScanEnter,/* Entry task */
    {
                {STS_PowerScan2BinarySearchCriterion, STS_PowerScan2BinarySearch}, /* Criterion1 and Exit task */
        {STS_PowerScan2ResetCriterion,      STS_PowerScan2Reset},
        {STS_PowerScan2CompleteCriterion,   STS_PowerScan2Complete},
                {0, 0}         /* End of Criterion/Exit task */
    },
    0,                 /* Regular task (none) */
    0,                 /* no counter */
    STS_PWRSCAN_STATE  /* state code */
};

STATE sts_binary_search_state = /* MAIN STS FSM, BINARY SEARCH state */
{
    STS_BinarySearchEnter,  /* Entry task */
    {
                {STS_BinarySearch2ReadyCriterion,        STS_BinarySearch2Ready},       /* Criterion1 and Exit task */
                {STS_BinarySearch2BinarySearchCriterion,  STS_BinarySearch2BinarySearch}, /* Criterion2 and Exit task */
                {0, 0}              /* End of Criterion/Exit task */
    },
    0,                      /* Regular task */
    0,                      /* no counter */
    STS_BINARY_SEARCH_STATE /* state code */
};

STATE sts_rescan_state = /* MAIN STS FSM, RESCAN state */
{
    STS_RescanEnter,  /* Entry task */
    {
        {STS_Rescan2ResetCriterion, STS_Rescan2Reset},
                {0, 0}       /* End of Criterion/Exit task */
    },
    0,               /* Regular task */
    0,               /* no counter */
    STS_RESCAN_STATE  /* state code */
};

STATE sts_ready_state = /* MAIN STS FSM, READY state */
{
    STS_ReadyEnter,  /* Entry task */
    {
        {STS_Ready2SRBinCriterion, STS_Ready2SRBin},
        {STS_Ready2BinarySearchCriterion, STS_Ready2BinarySearch},        
                {0, 0}       /* End of Criterion/Exit task */
    },
    0,               /* Regular task */
    0,               /* no counter */
    STS_READY_STATE  /* state code */
};

STATE sts_srbin_state = /* MAIN STS FSM, SRBIN state */
{
    STS_SRBinEnter,  /* Entry task */
    {
        {STS_SRBin2CompleteState, STS_SRBin2Complete},
                {0, 0}       /* End of Criterion/Exit task */
    },
    STS_SRBin,    /* Regular task */
    0,               /* no counter */
    STS_SRBIN_STATE  /* state code */
};

STATE sts_complete_state = /* MAIN STS FSM, COMPLETE state */
{
    STS_CompleteEnter,  /* Entry task */
    {
        {0, 0}       /* End of Criterion/Exit task */
    },
    0,    /* Regular task */
    0,               /* no counter */
    STS_COMPLETE_STATE  /* state code */
};

/* Function Implementation */
/*****************************************************************************/
/* STS_Start() */
/* MAIN FSM function  */
/*****************************************************************************/
static BOOL b_first_channel = True;
static BOOL s_skip_scan = False;     
static BOOL s_first_time = True;
static void 
STS_Start(FSM *fsm)
{  
   fsm->p_curr = &sts_reset_state; 
   b_first_channel = True;
   s_skip_scan = False;
   memset(&s_sts_channel_info,    0, sizeof(HAMARO_STS_CHANNEL_INFO)*STS_MAX_SCAN_CHANNELS);
   memset(&s_power_spectrum_data, 0, sizeof(HAMARO_STS_POWER_SPECTRUM_DATA));
   s_channel_info_index = 0;
   s_abort = False;
   s_first_time = True;
   STS_BTLAccumClearSelect(SRBIN_BTL_RESET_WHEN_REACQUIRE);
}


/*****************************************************************************/
/*                         FSM state functions                               */
/*****************************************************************************/
/* reset state */ 
static BOOL b_channel_found = False;
static unsigned long s_symbol_rate_hz;
static unsigned long s_carrier_freq_hz;

unsigned long STS_GetLastCarrierFreqHz()
{
    return s_carrier_freq_hz;
}

//static unsigned long prev_tuner_freq = 0;
static unsigned long s_freq_start = STS_START_FREQ_HZ;
static unsigned long s_freq_limit = TUNER_HIGH_LIMIT;
//static BOOL s_rescan = False;

/*****************************************************************************/
/* STS_ResetEnter() */
/*   */
/*****************************************************************************/
static void  
STS_ResetEnter()
{
    /* Disable all FSMs */
    FSM_Init(&bin_search_fsm);
    FSM_Init(&pwr_scan_fsm);
    FSM_Init(&sr_bin_fsm);

    b_channel_found = False;

    STS_SetUseMainBuffer(True); /* use main buffer */       
}

static BOOL   
STS_Reset2PowerScanCriterion()
{
    return (True);
}

static STATE* 
STS_Reset2PowerScan()
{
    DBG_CHECK_FSM_LIMITS(&sts_pwrscan_state);
    return &sts_pwrscan_state; 
}

/* power scan state */
static HAMARO_PWRSCAN_INPUT power_scan_input;
static void   
STS_PowerScanEnter()
{
    power_scan_input.bw_symbol_rate_mhz = STS_MAX_SYMBOL_RATE_MHZ;
    power_scan_input.observation_window = STS_OBERVATION_WINDOW_MAIN;
    power_scan_input.search_span_mhz    = STS_SEARCH_SPAN_MHZ_MAIN;
    power_scan_input.step_size_hz       = STS_STEP_SIZE_KHZ_MAIN * 1000;
    power_scan_input.symbol_rate_khz    = STS_MATCH_FILTER_CLK_MAIN * 1000;
    power_scan_input.tuner_freq_hz      = s_freq_start; 
    power_scan_input.full_scan          = True;

#if 1
    power_scan_input.stitch             = True;
    power_scan_input.smooth             = False;
#else 
    power_scan_input.stitch             = False;
    power_scan_input.smooth             = False;
#endif    
    
    power_scan_input.upper_freq_limit_hz= s_freq_limit;

    STSDBG_WR_UNSIGNED_LN("STS_PowerScanEnter::tuner_freq_hz = ", power_scan_input.tuner_freq_hz);

    if (power_scan_input.tuner_freq_hz < s_freq_limit)
    {
        FSM_Init(&pwr_scan_fsm);
        STS_SetUseMainBuffer(True); /* Use main buffer */
        PWRSCAN_SetAAGCFilter(True);

        STS_UpdateProgress(HAMARO_STS_POWER_METER_SCAN);

        PWRSCAN_Start(&pwr_scan_fsm, &power_scan_input);

        STSDBG_WR_STR("STS FSM::POWER SCAN FSM is STARTED", True);
    }
}

static BOOL PWRSCAN_SmoothingMedianFilter() /* use this only for the main buffer */
{
    return MedianFilter(s_power_spectrum_data.power, 
        s_power_spectrum_data.filled_buffer_len, 7);
    
}

/*static*/ void  
STS_ParsePowerDataInMainBuffer()
{
    /* do nothing */
    unsigned short mean=0;
    unsigned int counts=0,countw=0;
    unsigned int i=0, j=0,k=0;
    int meanagc=0;
    unsigned char segl=0;
    STD_NUM std;
    
    PWRSCAN_GetSegmentLength(&segl);
    i = 0;
    while(i<segl)
    {
      trace_new( TRACE_FLAG, "s_pwrscan_buffer_info[%02d].agcacc = %02d\r\n", i, 
                                s_pwrscan_buffer_info[i].agcacc);
        meanagc += s_pwrscan_buffer_info[i].agcacc;
        
        i++;
        if (i==segl)
            break;
        s_pwrscan_buffer_info_delta[i-1] = s_pwrscan_buffer_info[i].agcacc - s_pwrscan_buffer_info[i-1].agcacc;
    }
    meanagc = meanagc/segl;
    if (meanagc<0)