hamaro_findrise.c

机顶盒Hamaro解调器驱动。包含自动搜台

/* hamaro_findrise.c */
/*+++ *******************************************************************\
*
*  Abstract:
*
*       Hamaro find rise edge and find rise range 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_findrise.c, 4, 2006-4-8 0:26:38, ShenWei Wang$
*
*     Copyright (c) 2005 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/
#include "hamaro_findrise.h"

#if HAMARO_SCAN_THE_SKY

#include "hamaro_fsm.h"
#include "hamaro_sts.h"
#include "hamaro_findfall.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 unsigned long sts_fsm_coding; 
FSM rise_edge_fsm  = {&sts_fsm_coding, 0x00000F00, 0, 0, 0, 0}; 
FSM rise_range_fsm = {&sts_fsm_coding, 0x0000F000, 0, 0, 0, 0}; 

static HAMARO_STS_CURVATURE_POINTS s_find_rise_range_curvature;
static BOOL s_step_forward = True;
static BOOL s_abort_state = False; // must be implemented as a new state
static BOOL isFromReset2RiseHump = False;
/*****************************************************************************/
/*                               RISE EDGE FSM                               */
/*****************************************************************************/
/* Function prototypes */
/* Rise edge Reset state */
static void   RISEEDGE_ResetEnter();
static void   RISEEDGE_Reset();

static BOOL   RISEEDGE_Reset2RiseUphillCriterion();
static STATE* RISEEDGE_Reset2RiseUphill();

static BOOL   RISEEDGE_Reset2RiseHumpCriterion();
static STATE* RISEEDGE_Reset2RiseHump();

static BOOL   RISEEDGE_Reset2RiseDownHillCriterion();
static STATE* RISEEDGE_Reset2RiseDownHill();

static BOOL   RISEEDGE_Reset2RiseTroughCriterion();
static STATE* RISEEDGE_Reset2RiseTrough();

static BOOL   RISEEDGE_Reset2RiseFlatCriterion();
static STATE* RISEEDGE_Reset2RiseFlat();

static BOOL   RISEEDGE_Reset2RiseUnknownCriterion();
static STATE* RISEEDGE_Reset2RiseUnknown();


/* Rise edge uphill state */
static void   RISEEDGE_UphillEnter();
static BOOL   RISEEDGE_Uphill2RiseReadyCriterion();
static STATE* RISEEDGE_Uphill2RiseReady();

/* Rise edge ready state */
static void   RISEEDGE_ReadyEnter();

/* Rise edge hump state */
static void   RISEEDGE_Hump();

static BOOL   RISEEDGE_Hump2RiseUphillCriterion();
static STATE* RISEEDGE_Hump2RiseUphill();

static BOOL   RISEEDGE_Hump2RiseDownHillCriterion();
static STATE* RISEEDGE_Hump2RiseDownHill();

static BOOL   RISEEDGE_Hump2RiseTroughCriterion();
static STATE* RISEEDGE_Hump2RiseTrough();

static BOOL   RISEEDGE_Hump2RiseFlatCriterion();
static STATE* RISEEDGE_Hump2RiseFlat();

static BOOL   RISEEDGE_Hump2RiseUnknownCriterion();
static STATE* RISEEDGE_Hump2RiseUnknown();


/* Rise edge downhill state */
static void   RISEEDGE_Downhill();

static BOOL   RISEEDGE_Downhill2RiseReadyCriterion();
static STATE* RISEEDGE_Downhill2RiseReady();

static BOOL   RISEEDGE_Downhill2RiseUphillCriterion();
static STATE* RISEEDGE_Downhill2RiseUphill();

static BOOL   RISEEDGE_Downhill2RiseHumpCriterion();
static STATE* RISEEDGE_Downhill2Hump();

//static BOOL   RISEEDGE_Downhill2DownhillCriterion();
//static STATE* RISEEDGE_Downhill2Downhill();

static BOOL   RISEEDGE_Downhill2RiseTroughCriterion();
static STATE* RISEEDGE_Downhill2RiseTrough();

static BOOL   RISEEDGE_Downhill2RiseFlatCriterion();
static STATE* RISEEDGE_Downhill2RiseFlat();

static BOOL   RISEEDGE_Downhill2RiseUnknownCriterion();
static STATE* RISEEDGE_Downhill2RiseUnknown();


/* Rise edge trough state */
static void   RISEEDGE_Trough();

static BOOL   RISEEDGE_Trough2RiseReadyCriterion();
static STATE* RISEEDGE_Trough2RiseReady();

static BOOL   RISEEDGE_Trough2RiseUphillCriterion();
static STATE* RISEEDGE_Trough2RiseUphill();

static BOOL   RISEEDGE_Trough2RiseHumpCriterion();
static STATE* RISEEDGE_Trough2RiseHump();

static BOOL   RISEEDGE_Trough2RiseDownhillCriterion();
static STATE* RISEEDGE_Trough2RiseDownhill();

static BOOL   RISEEDGE_Trough2RiseFlatCriterion();
static STATE* RISEEDGE_Trough2RiseFlat();

static BOOL   RISEEDGE_Trough2RiseUnknownCriterion();
static STATE* RISEEDGE_Trough2RiseUnknown();


/* Rise edge flat state */
static void   RISEEDGE_Flat(); /* Regular task */

static BOOL   RISEEDGE_Flat2RiseReadyCriterion();
static STATE* RISEEDGE_Flat2RiseReady();

static BOOL   RISEEDGE_Flat2RiseUphillCriterion();
static STATE* RISEEDGE_Flat2RiseUphill();

static BOOL   RISEEDGE_Flat2RiseHumpCriterion();
static STATE* RISEEDGE_Flat2RiseHump();

static BOOL   RISEEDGE_Flat2RiseDownhillCriterion();
static STATE* RISEEDGE_Flat2RiseDownhill();

static BOOL   RISEEDGE_Flat2RiseTroughCriterion();
static STATE* RISEEDGE_Flat2RiseTrough();

static BOOL   RISEEDGE_Flat2RiseUnknownCriterion();
static STATE* RISEEDGE_Flat2RiseUnknown();

/* Rise edge unknown state */
static void   RISEEDGE_UnknownEnter();

static BOOL   RISEEDGE_Unknown2ResetCriterion();   
static STATE* RISEEDGE_Unknown2Reset();

/* State tables */
STATE rise_edge_reset_state = /* FIND_RISE_EDGE FSM, RESET state */
{
	RISEEDGE_ResetEnter, /* Entry task */
   	{
      		{RISEEDGE_Reset2RiseUphillCriterion,   RISEEDGE_Reset2RiseUphill},   /* Criterion1 and Exit task */
      		{RISEEDGE_Reset2RiseHumpCriterion,     RISEEDGE_Reset2RiseHump},     /* Criterion2 and Exit task */
      		{RISEEDGE_Reset2RiseDownHillCriterion, RISEEDGE_Reset2RiseDownHill}, /* Criterion3 and Exit task */
      		{RISEEDGE_Reset2RiseTroughCriterion,   RISEEDGE_Reset2RiseTrough},   /* Criterion4 and Exit task */
      		{RISEEDGE_Reset2RiseFlatCriterion,     RISEEDGE_Reset2RiseFlat},     /* Criterion5 and Exit task */
      		{RISEEDGE_Reset2RiseUnknownCriterion,  RISEEDGE_Reset2RiseUnknown},  /* Criterion6 and Exit task */
      		{0,0} /* End of Criterion/Exit task */
   	},
   	RISEEDGE_Reset, /* Regular/Routine task */
   	0, /* No counter */
   	RISEEDGE_RESET_STATE /* state code */	
};

STATE rise_edge_uphill_state = /* FIND_RISE_EDGE FSM, UPHILL state */
{
    RISEEDGE_UphillEnter, /* Entry task */
    {
        {RISEEDGE_Uphill2RiseReadyCriterion, RISEEDGE_Uphill2RiseReady},
        {0,0} /* No Criterion/Exit task */
    },
    0, /* Regular task */
    0,
    RISEEDGE_UPHILL_STATE
};

STATE rise_edge_ready_state = /* FIND_RISE_EDGE FSM, READY state */
{
    RISEEDGE_ReadyEnter, /* Entry task */
    {
        {0,0} /* No Criterion/Exit task */
    },
    0, /* Regular task */
    0,
    RISEEDGE_READY_STATE
};

STATE rise_edge_hump_state = /* FIND_RISE_EDGE FSM, HUMP state */
{
    0, /* Entry task */
    {
      	{RISEEDGE_Hump2RiseUphillCriterion,   RISEEDGE_Hump2RiseUphill},  
      	{RISEEDGE_Hump2RiseDownHillCriterion, RISEEDGE_Hump2RiseDownHill},
      	{RISEEDGE_Hump2RiseTroughCriterion,   RISEEDGE_Hump2RiseTrough},  
      	{RISEEDGE_Hump2RiseFlatCriterion,     RISEEDGE_Hump2RiseFlat},    
      	{RISEEDGE_Hump2RiseUnknownCriterion,  RISEEDGE_Hump2RiseUnknown}, 
        {0,0} /* No Criterion/Exit task */
    },
    RISEEDGE_Hump, /* Regular task */
    0,
    RISEEDGE_HUMP_STATE
};

STATE rise_edge_downhill_state = /* FIND_RISE_EDGE FSM, DOWNHILL state */
{
    0, /* Entry task */
    {
     //   {RISEEDGE_Downhill2DownhillCriterion,    RISEEDGE_Downhill2Downhill},    /* Criterion and Exit task */
        {RISEEDGE_Downhill2RiseReadyCriterion,   RISEEDGE_Downhill2RiseReady},
      	{RISEEDGE_Downhill2RiseUphillCriterion,  RISEEDGE_Downhill2RiseUphill},  
      	{RISEEDGE_Downhill2RiseHumpCriterion,    RISEEDGE_Downhill2Hump},        
      	{RISEEDGE_Downhill2RiseTroughCriterion,  RISEEDGE_Downhill2RiseTrough},  
      	{RISEEDGE_Downhill2RiseFlatCriterion,    RISEEDGE_Downhill2RiseFlat},    
      	{RISEEDGE_Downhill2RiseUnknownCriterion, RISEEDGE_Downhill2RiseUnknown}, 
        {0,0} /* No Criterion/Exit task */
    },
    RISEEDGE_Downhill, /* Regular task */
    0,
    RISEEDGE_DOWNHILL_STATE
};

STATE rise_edge_trough_state = /* FIND_RISE_EDGE FSM, TROUGH state */
{
    0, /* Entry task */
    {
        {RISEEDGE_Trough2RiseReadyCriterion,    RISEEDGE_Trough2RiseReady},  
      	{RISEEDGE_Trough2RiseUphillCriterion,   RISEEDGE_Trough2RiseUphill},  
      	{RISEEDGE_Trough2RiseHumpCriterion,     RISEEDGE_Trough2RiseHump},    
      	{RISEEDGE_Trough2RiseDownhillCriterion, RISEEDGE_Trough2RiseDownhill},
      	{RISEEDGE_Trough2RiseFlatCriterion,     RISEEDGE_Trough2RiseFlat},    
      	{RISEEDGE_Trough2RiseUnknownCriterion,  RISEEDGE_Trough2RiseUnknown}, 
        {0,0} /* No Criterion/Exit task */
    },
    RISEEDGE_Trough, /* Regular task */
    0,
    RISEEDGE_TROUGH_STATE
};

STATE rise_edge_flat_state = /* FIND_RISE_EDGE FSM, FLAT state */
{
    0, /* Entry task */
    {
      	{RISEEDGE_Flat2RiseReadyCriterion,    RISEEDGE_Flat2RiseReady},  
      	{RISEEDGE_Flat2RiseUphillCriterion,   RISEEDGE_Flat2RiseUphill},  
      	{RISEEDGE_Flat2RiseHumpCriterion,     RISEEDGE_Flat2RiseHump},    
      	{RISEEDGE_Flat2RiseDownhillCriterion, RISEEDGE_Flat2RiseDownhill},
      	{RISEEDGE_Flat2RiseTroughCriterion,   RISEEDGE_Flat2RiseTrough},  
      	{RISEEDGE_Flat2RiseUnknownCriterion,  RISEEDGE_Flat2RiseUnknown}, 
        {0,0} /* No Criterion/Exit task */
    },
    RISEEDGE_Flat, /* Regular task */
    0,
    RISEEDGE_FLAT_STATE
};

STATE rise_edge_unknown_state = /* FIND_RISE_EDGE FSM, UNKNOWN state */
{
    RISEEDGE_UnknownEnter, /* Entry task */
    {
        {RISEEDGE_Unknown2ResetCriterion,   RISEEDGE_Unknown2Reset},  /* Criterion1 and Exit task */
        {0,0} /* No Criterion/Exit task */
    },
    0, /* Regular task */
    0,
    RISEEDGE_UNKNOWN_STATE
};


/*****************************************************************************/
/* RISEEDGE_Start() */
/* Main FSM function  */
/*****************************************************************************/
static BOOL s_one_time = True; 
static BOOL s_first_freq = 0;
void 
RISEEDGE_Start(FSM *fsm, BOOL first_time, unsigned long first_freq)
{  
   fsm->p_curr = &rise_edge_reset_state; 
   s_one_time = first_time;
   s_first_freq = first_freq;
   s_step_forward = True;
   s_abort_state = False;
}

/* --- RISEEDGE Reset State --- */
/*****************************************************************************/
/* RISEEDGE_ResetEnter() */
/*   */
/*****************************************************************************/
static unsigned short s_step_size;
static HAMARO_STS_PATTERN s_pattern = PATTERN_UNKNOWN;
static short s_pattern_delta = STS_PATTERN_TEST_DELTA;

static void  
RISEEDGE_ResetEnter()
{
    unsigned short start_index;

    s_step_size = STS_FINDRISE_DEFAULT_STEP_SIZE; /* 500 kHz if scan step size was 125 kHz */
    
    if (s_one_time == True)
    {
        STS_StartAllOver(s_step_size, 0xFFFF);
        s_one_time = False;
    }
    else
    {
        STSDBG_WR_UNSIGNED_LN("RISEEDGE_ResetEnter::start_freq = ", s_first_freq);
        start_index = STS_GetIndexFromFreq(s_first_freq);
        STS_StartAllOver(s_step_size, start_index);
    }
    
    STS_ResetCurvaturePoints(&s_find_rise_range_curvature, STS_EDGE_RISING);  
    FINDFALL_ResetCurvaturePoints();

    s_pattern_delta = STS_GetPatternDelta();
}

/*****************************************************************************/
/* RISEEDGE_Reset() */
/* Regular task */
/*****************************************************************************/
static void 
RISEEDGE_Reset()
{  
    HAMARO_STS_SAMPLE* p_samples;
    
    p_samples = STS_GetSamples();

    s_pattern = STS_PatternTest(*p_samples->p_power[0], 
                                *p_samples->p_power[1],
                                *p_samples->p_power[2], 
                                s_pattern_delta);
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseUphillCriterion() */
/*   */
/*****************************************************************************/
static BOOL  
RISEEDGE_Reset2RiseUphillCriterion()
{
    if (s_pattern == PATTERN_UPHILL)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseUphill() */
/*   */
/*****************************************************************************/
static STATE*
RISEEDGE_Reset2RiseUphill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_uphill_state);
	return &rise_edge_uphill_state; 
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseHumpCriterion() */
/*   */
/*****************************************************************************/
static BOOL  
RISEEDGE_Reset2RiseHumpCriterion()
{
    if (s_pattern == PATTERN_HUMP)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseHump() */
/*   */
/*****************************************************************************/
static STATE*
RISEEDGE_Reset2RiseHump()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_hump_state);
    isFromReset2RiseHump = True;
	return &rise_edge_hump_state; 
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseDownHillCriterion() */
/*   */
/*****************************************************************************/
static BOOL  
RISEEDGE_Reset2RiseDownHillCriterion()
{
    if (s_pattern == PATTERN_DOWNHILL)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseDownHill() */
/*   */
/*****************************************************************************/
static STATE*
RISEEDGE_Reset2RiseDownHill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_downhill_state);
	return &rise_edge_downhill_state; 
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseTroughCriterion() */
/*   */
/*****************************************************************************/
static BOOL  
RISEEDGE_Reset2RiseTroughCriterion()
{
    if (s_pattern == PATTERN_TROUGH)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseTrough() */
/*   */
/*****************************************************************************/
static STATE*
RISEEDGE_Reset2RiseTrough()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_trough_state);
	return &rise_edge_trough_state;
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseFlatCriterion() */
/*   */
/*****************************************************************************/
static BOOL  
RISEEDGE_Reset2RiseFlatCriterion()
{
    if (s_pattern == PATTERN_FLAT)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseFlat() */
/*   */
/*****************************************************************************/
static STATE*
RISEEDGE_Reset2RiseFlat()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_flat_state);
	return &rise_edge_flat_state;
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseUnknownCriterion() */
/*   */
/*****************************************************************************/
static BOOL  
RISEEDGE_Reset2RiseUnknownCriterion()
{
    if (s_pattern == PATTERN_UNKNOWN)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Reset2RiseUnknown() */
/*   */
/*****************************************************************************/