hamaro_pwrscan.c

QPSK Tuner details, for conexant chipset.

/* hamaro_pwrscan.c */
/*+++ *******************************************************************\
*
*  Abstract:
*
*       Hamaro Power Scan FSM implementation.
*
*  Created: 12/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_pwrscan.c, 1, 12/15/2005 1:43:00 PM, Amar Puttur$
*
*     Copyright (c) 2005, 2006 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/
#include <stdlib.h> /* ANSI Standard */
#include <time.h> 

#include "hamaro_sts.h"

#if HAMARO_SCAN_THE_SKY

#include "hamaro_pwrscan.h"
#include "hamaro_fsm.h"
#include "kal.h"

#define  PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE       0
#define  STS_ENABLE_VERBOSE_LOG                         0

#if PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE
#include <stdio.h>
#endif /* PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE */


#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 unsigned long sts_fsm_coding; 
FSM pwr_scan_fsm = {&sts_fsm_coding, 0xF0000000, 0, 0, 0, 0}; 

extern void STS_ParsePowerDataInMainBuffer();
extern void STS_CheckCandidateWithStitcheddata();

static HAMARO_PWRSCAN_DATA s_power_scan_data;

static unsigned short* p_power_reading = 0;
static unsigned long*  p_freq_reading = 0;
static signed   char*  p_agcacc = 0;
static unsigned short* p_filled_buffer_length = 0;
static unsigned short* p_max_pwr_reading = 0;

//extern HAMARO_STS_POWER_SPECTRUM_DATA  s_power_spectrum_data;
//extern 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_PWRSCAN_BUFFER_INFO s_pwrscan_buffer_info[STS_MAX_NUM_OF_SCAN_SEGMENTS];
static unsigned short s_buffer_info_index;
static unsigned short s_scaled_max_power_reading = 0;

static BOOL s_aagc_filter = True;
static BOOL s_continue_scan = False;
static BOOL s_stop = False;
static long  fsample = PWRSCAN_SAMPLE_RATE;

/*****************************************************************************/
/*                          POWER SCAN FSM                                   */
/*****************************************************************************/
/* Function prototypes */
/* Power scan: Reset state */
static void   PWRSCAN_ResetEnter();

static BOOL   PWRSCAN_Reset2TuneCriterion();
static STATE* PWRSCAN_Reset2Tune();

static BOOL   PWRSCAN_Reset2AbortCriterion();
static STATE* PWRSCAN_Reset2Abort();

/* Power scan: Tune state */
static void   PWRSCAN_TuneEnter();

static BOOL   PWRSCAN_Tune2StartCriterion(); 
static STATE* PWRSCAN_Tune2Start();
static BOOL   PWRSCAN_Tune2AbortCriterion();
static STATE* PWRSCAN_Tune2Abort();

/* Power scan: Start state */
static void   PWRSCAN_StartEnter();

static BOOL   PWRSCAN_Start2StepCriterion();
static STATE* PWRSCAN_Start2Step();

static BOOL   PWRSCAN_Start2AbortCriterion();
static STATE* PWRSCAN_Start2Abort();

/* Power scan: Step state */
static void   PWRSCAN_StepEnter();
static void   PWRSCAN_Step();

static BOOL   PWRSCAN_Step2StopCriterion();
static STATE* PWRSCAN_Step2Stop();

static BOOL   PWRSCAN_Step2AbortCriterion();
static STATE* PWRSCAN_Step2Abort();

/* Power scan: Stop state */
static void   PWRSCAN_StopEnter();

static BOOL   PWRSCAN_Stop2ReadyCriterion();
static STATE* PWRSCAN_Stop2Ready();
static BOOL   PWRSCAN_Stop2TuneCriterion();
static STATE* PWRSCAN_Stop2Tune();

/* Power scan: Abort state */
static void   PWRSCAN_AbortEnter();

/* Power scan: Ready state */
static void   PWRSCAN_ReadyEnter();


/* State tables */
STATE pwrscan_reset_state = /* PWRSCAN FSM, RESET state */
{
	PWRSCAN_ResetEnter, /* Entry task */
   	{
      	{PWRSCAN_Reset2TuneCriterion,  PWRSCAN_Reset2Tune},      
        {PWRSCAN_Reset2AbortCriterion, PWRSCAN_Reset2Abort},
      	{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	PWRSCAN_RESET_STATE /* state code */	
};


STATE pwrscan_tune_state = /* PWRSCAN FSM, TUNE state */
{
	PWRSCAN_TuneEnter, /* Entry task */
   	{
        {PWRSCAN_Tune2AbortCriterion, PWRSCAN_Tune2Abort},   /* higher priority */
      	{PWRSCAN_Tune2StartCriterion, PWRSCAN_Tune2Start},   
      	{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	PWRSCAN_TUNE_STATE /* state code */	
};


STATE pwrscan_start_state = /* PWRSCAN FSM, START state */
{
    PWRSCAN_StartEnter, /* Entry task */
    {
        {PWRSCAN_Start2AbortCriterion, PWRSCAN_Start2Abort}, /* higher priority */
        {PWRSCAN_Start2StepCriterion,  PWRSCAN_Start2Step},
        {0,0} 
    },
    0, /* Regular task */
    0,
    PWRSCAN_START_STATE
};


STATE pwrscan_step_state = /* PWRSCAN FSM, STEP state */
{
    PWRSCAN_StepEnter, /* Entry task */
    {
        {PWRSCAN_Step2AbortCriterion, PWRSCAN_Step2Abort},   /* higher priority */
        {PWRSCAN_Step2StopCriterion,  PWRSCAN_Step2Stop},
        {0,0} 
    },
    PWRSCAN_Step,      /* Regular task */
    0,
    PWRSCAN_STEP_STATE
};


STATE pwrscan_stop_state = /* PWRSCAN FSM, STOP state */
{
	PWRSCAN_StopEnter, /* Entry task */
   	{
        {PWRSCAN_Stop2ReadyCriterion, PWRSCAN_Stop2Ready},
        {PWRSCAN_Stop2TuneCriterion,  PWRSCAN_Stop2Tune},
   		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	PWRSCAN_STOP_STATE 
};


STATE pwrscan_ready_state = /* PWRSCAN FSM, READY state */
{
	PWRSCAN_ReadyEnter, /* Entry task */
   	{
   		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	PWRSCAN_READY_STATE /* state code (uses bits [11:8] position) */	
};


STATE pwrscan_abort_state = /* PWRSCAN FSM, ABORT state */
{
	PWRSCAN_AbortEnter, /* Entry task */
   	{
   		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	PWRSCAN_ABORT_STATE /* state code (uses bits [11:8] position) */	
};

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

/*****************************************************************************/
/* PWRSCAN_Start() */
/* Main FSM function  */
/*****************************************************************************/
void 
PWRSCAN_Start(FSM *fsm, HAMARO_PWRSCAN_INPUT* p_power_scan_input)
{
    if (p_power_scan_input == 0)
    {
        return;
    }

    memcpy(&s_power_scan_data.power_scan_input, p_power_scan_input, sizeof(HAMARO_PWRSCAN_INPUT));

    fsm->p_curr = &pwrscan_reset_state; 
}


/*****************************************************************************/
/* PWRSCAN_ResetBuffers() */
/*****************************************************************************/
static BOOL
PWRSCAN_ResetBuffers()
{
    if (STS_GetUseMainBuffer() == True)
    {
        memset(&s_power_spectrum_data.power[0],   0, sizeof(unsigned short)*(STS_MAX_INDEX-1));
        memset(&s_power_spectrum_data.abs_freq[0],0, sizeof(unsigned long)*(STS_MAX_INDEX-1));
        memset(&s_pwrscan_buffer_info, 0, sizeof(HAMARO_PWRSCAN_BUFFER_INFO) * STS_MAX_NUM_OF_SCAN_SEGMENTS);
        s_power_spectrum_data.filled_buffer_len = 0;
        s_power_spectrum_data.agcacc = 0;
        s_buffer_info_index = 0;
    }
    else
    {
        memset(&s_power_spectrum_data.sub_power[0],   0, sizeof(unsigned short)*(STS_MAX_SUB_INDEX-1));
        memset(&s_power_spectrum_data.sub_abs_freq[0],0, sizeof(unsigned long)*(STS_MAX_SUB_INDEX-1));
        s_power_spectrum_data.filled_sub_buffer_len = 0;
        s_power_spectrum_data.sub_agcacc = 0;
    }        
    return (True);
}

void
PWRSCAN_SetAAGCFilter(BOOL value) /* True = apply filter; False = do not apply filter */
{
    if (value == True)
    {
        STSDBG_WR_STR("PWRSCAN_SetAAGCFilter::AAGC FILTER IS ON", True);
    }
    else
    {
        STSDBG_WR_STR("PWRSCAN_SetAAGCFilter::AAGC FILTER IS OFF", True);
    }
    s_aagc_filter = value;
}

static BOOL
PWRSCAN_IsAAGCFilter() /* True = apply filter; False = do not apply filter */
{
    return (s_aagc_filter);
}

/* MUST BE USED ONLY IN THE SCAN_THE_SKY MODULE */
BOOL
PWRSCAN_AAGCControl(BOOL freeze)
{
    if (freeze == True)
    {
        (hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x72, 0x01, &hamaro_nim_list.nim[0]->iostatus);
        if (hamaro_nim_list.nim[0]->iostatus != 0UL)  return(False);
    }
    else
    {
        (hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x72, 0xFF, &hamaro_nim_list.nim[0]->iostatus);
        if (hamaro_nim_list.nim[0]->iostatus != 0UL)  return(False);
        (hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x72, 0x00, &hamaro_nim_list.nim[0]->iostatus);
        if (hamaro_nim_list.nim[0]->iostatus != 0UL)  return(False);
    }
    return True;
}

BOOL
PWRSCAN_BTLAccClear()
{   /* Main Accum = 0x02, Sub Accum = 0x00 */
    (hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x3A, 0x08, &hamaro_nim_list.nim[0]->iostatus);
    if (hamaro_nim_list.nim[0]->iostatus != 0UL)  return(False);

    (hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x3B, 0x00, &hamaro_nim_list.nim[0]->iostatus);
    if (hamaro_nim_list.nim[0]->iostatus != 0UL)  return(False);

    return True;
}

/* END OF - MUST BE USED ONLY IN THE SCAN_THE_SKY MODULE - */

BOOL
PWRSCAN_IsBufferEmpty()
{
    if (STS_GetUseMainBuffer() == True)
    {
        if (s_power_spectrum_data.filled_buffer_len == 0)
        {
            return (True);
        }
    }
    else
    {
        if (s_power_spectrum_data.filled_sub_buffer_len == 0)
        {
            return (True);
        }
    }
    return (False);
}

/*****************************************************************************/
/* PWRSCAN_GetMaxNumberSets() */
/*****************************************************************************/
static unsigned short
PWRSCAN_GetMaxNumberSets(unsigned char search_span_mhz, unsigned short number_freq_cnt, unsigned long step_size_hz)
{
    return ( (unsigned short) ( (((unsigned long)search_span_mhz * 1000000UL) + 500000UL) / ((unsigned long)number_freq_cnt * step_size_hz) ) );
}

static unsigned short
PWRSCAN_GetNumFreqCount(unsigned char match_filter_clk_mhz, unsigned short desired_step_size_khz)
{
    unsigned long constraint1, constraint2;

    STSDBG_WR_INT_LN("match_filter_clk_hz = ", match_filter_clk_mhz);
    STSDBG_WR_INT_LN("desired_step_size_khz = ", desired_step_size_khz);

    constraint1 = STS_MATCH_FILTER_CONSTANT/match_filter_clk_mhz;
    STSDBG_WR_INT_LN("constraint1 = ", constraint1);

    /* (((0.25 * mfclk_mhz) * 2)/step_size) + 1 */
    constraint2 = ((((250 * (match_filter_clk_mhz*1000)) * 2) / desired_step_size_khz)/1000) + 1;
    STSDBG_WR_INT_LN("constraint2 = ", constraint2);
#if HAMARO_WIN_DEBUG
    WINDBG_FileWriteNewLine();
#endif /* HAMARO_WIN_DEBUG */   

    if (constraint1 < constraint2)