hamaro_fsm.c

QPSK Tuner details, for conexant chipset.

/*****************************************************************************/
#if HAMARO_INCLUDE_DEBUG
/*****************************************************************************/
/* DEBUG_Init() */
/*   */
/*****************************************************************************/
void DEBUG_Init()
{
    unsigned char index;

	for (index = 0; index < STS_MAX_STATE_SEQUENCES; index++)
	{
	    fsm_sequence_data[index].state = 0;
	    fsm_sequence_data[index].time_spent = 0;  	
	}
	sequence_index = 0;
}

/*****************************************************************************/
/* DEBUG_UpdateTimeSpent() */
/*   */
/*****************************************************************************/
void DEBUG_UpdateTimeSpent(unsigned short time)
{
    time = 0; /* TBD */
}

/*****************************************************************************/
/* DEBUG_UpdateStateSequence() */
/*   */
/*****************************************************************************/
void DEBUG_UpdateStateSequence(unsigned long state)
{
	if (sequence_index < STS_MAX_STATE_SEQUENCES)
	{
		fsm_sequence_data[sequence_index].state = state;
		sequence_index++;
	}
}

/*****************************************************************************/
/* DEBUG_DumpStateSequence() */
/*   */
/*****************************************************************************/
void   DEBUG_DumpStateSequence()
{
    unsigned char index;

    STSDBG_WR_STR("\nState sequence...\n-----------------\n", False);

    for (index = 0; index < sequence_index; index++)
    {
        STSDBG_WR_INT_LN("State: ", fsm_sequence_data[index].state);
    }
}

/* Debug functions to set and get state_limits */
static unsigned long state_code_limits;
/*****************************************************************************/
/* DEBUG_CheckFSMLimits() */
/*   */
/*****************************************************************************/
void 
DEBUG_SetFSMLimits(unsigned long limits)
{
    state_code_limits = limits;
}

/*****************************************************************************/
/* DEBUG_CheckFSMLimits() */
/*   */
/*****************************************************************************/
static unsigned long 
DEBUG_GetFSMLimits(void)
{
	return state_code_limits;
}

/*****************************************************************************/
/* DEBUG_StateCode2String() */
/*   */
/*****************************************************************************/
static void
DEBUG_StateCode2String(unsigned long coding)
{
#if HAMARO_WIN_DEBUG
    STSDBG_WR_HEX("FSM State = ", coding);

    switch (coding)
    {   /* STS FSM */
        case STS_RESET_STATE:           STSDBG_WR_STR("[STS_RESET_STATE]", True);          break; /* 1 */
        case STS_PWRSCAN_STATE:         STSDBG_WR_STR("[STS_PWRSCAN_STATE]", True);        break; /* 2 */
        case STS_RISING_EDGE_STATE:     STSDBG_WR_STR("[STS_RISING_EDGE_STATE]", True);    break; /* 3 */
        case STS_BINARY_SEARCH_STATE:   STSDBG_WR_STR("[STS_BINARY_SEARCH_STATE]", True);  break; /* 4 */
        case STS_FALLING_EDGE_STATE:    STSDBG_WR_STR("[STS_FALLING_EDGE_STATE]", True);   break; /* 5 */
        case STS_RESCAN_STATE:          STSDBG_WR_STR("[STS_RESCAN_STATE]", True);         break; /* 6 */
        case STS_READY_STATE:           STSDBG_WR_STR("[STS_READY_STATE]", True);          break; /* 7 */            
        case STS_SRBIN_STATE:           STSDBG_WR_STR("[STS_SRBIN_STATE]", True);          break; /* 8 */            
        case STS_COMPLETE_STATE:        STSDBG_WR_STR("[STS_COMPLETE_STATE]", True);       break; /* 9 */
        /* BINARY SEARCH FSM */
        case BINSEARCH_RESET_STATE:     STSDBG_WR_STR("[BINSEARCH_RESET_STATE]", True);    break; /* (1 << 4) */
        case BINSEARCH_BEGIN_STATE:		STSDBG_WR_STR("[BINSEARCH_BEGIN_STATE]", True);    break; /* (2 << 4) */  
        case BINSEARCH_CONVEX_STATE:    STSDBG_WR_STR("[BINSEARCH_CONVEX_STATE]", True);   break; /* (3 << 4) */
        case BINSEARCH_CONCAVE_STATE:   STSDBG_WR_STR("[BINSEARCH_CONCAVE_STATE]", True);  break; /* (4 << 4) */
        case BINSEARCH_READY_STATE:     STSDBG_WR_STR("[BINSEARCH_READY_STATE]", True);    break; /* (5 << 4) */
        /* RISING EDGE FSM */
        case RISEEDGE_UPHILL_STATE:     STSDBG_WR_STR("[RISEEDGE_UPHILL_STATE]", True);    break; /* (1 << 8) */
        case RISEEDGE_DOWNHILL_STATE:   STSDBG_WR_STR("[RISEEDGE_DOWNHILL_STATE]", True);  break; /* (2 << 8) */
        case RISEEDGE_FLAT_STATE:       STSDBG_WR_STR("[RISEEDGE_FLAT_STATE]", True);      break; /* (3 << 8) */
        case RISEEDGE_TROUGH_STATE:     STSDBG_WR_STR("[RISEEDGE_TROUGH_STATE]", True);    break; /* (4 << 8) */
        case RISEEDGE_PEAK_STATE:       STSDBG_WR_STR("[RISEEDGE_PEAK_STATE]", True);      break; /* (5 << 8) */
        case RISEEDGE_UNKNOWN_STATE:    STSDBG_WR_STR("[RISEEDGE_UNKNOWN_STATE]", True);   break; /* (6 << 8) */
        case RISEEDGE_RESET_STATE:      STSDBG_WR_STR("[RISEEDGE_RESET_STATE]", True);     break; /* (7 << 8) */
        case RISEEDGE_READY_STATE:      STSDBG_WR_STR("[RISEEDGE_READY_STATE]", True);     break; /* (8 << 8) */            
        /* RISING RANGE FSM */
        case RISERANGE_RESET_STATE:     STSDBG_WR_STR("[RISERANGE_RESET_STATE]", True);    break; /* (1 << 12) */
        case RISERANGE_CONVEX_STATE:    STSDBG_WR_STR("[RISERANGE_CONVEX_STATE]", True);   break; /* (2 << 12) */
        case RISERANGE_CONCAVE_STATE:   STSDBG_WR_STR("[RISERANGE_CONCAVE_STATE]", True);  break; /* (3 << 12) */
        case RISERANGE_READY_STATE:     STSDBG_WR_STR("[RISERANGE_READY_STATE]", True);    break; /* (4 << 12) */
        /* FALLING EDGE FSM */
        case FALLEDGE_UPHILL_STATE:     STSDBG_WR_STR("[FALLEDGE_UPHILL_STATE]", True);    break; /* (1 << 16) */
        case FALLEDGE_DOWNHILL_STATE:   STSDBG_WR_STR("[FALLEDGE_DOWNHILL_STATE]", True);  break; /* (2 << 16) */
        case FALLEDGE_FLAT_STATE:       STSDBG_WR_STR("[FALLEDGE_FLAT_STATE]", True);      break; /* (3 << 16) */
        case FALLEDGE_TROUGH_STATE:     STSDBG_WR_STR("[FALLEDGE_TROUGH_STATE]", True);    break; /* (4 << 16) */
        case FALLEDGE_PEAK_STATE:       STSDBG_WR_STR("[FALLEDGE_PEAK_STATE]", True);      break; /* (5 << 16) */
        case FALLEDGE_UNKNOWN_STATE:    STSDBG_WR_STR("[FALLEDGE_UNKNOWN_STATE]", True);   break; /* (6 << 16) */
        case FALLEDGE_RESET_STATE:      STSDBG_WR_STR("[FALLEDGE_RESET_STATE]", True);     break; /* (7 << 16) */
        case FALLEDGE_ABORT_STATE:      STSDBG_WR_STR("[FALLEDGE_ABORT_STATE]", True);     break; /* (8 << 16) */                        
        case FALLEDGE_READY_STATE:      STSDBG_WR_STR("[FALLEDGE_READY_STATE]", True);     break; /* (9 << 16) */            
        /* FALLING RANGE FSM */
        case FALLRANGE_RESET_STATE:     STSDBG_WR_STR("[FALLRANGE_RESET_STATE]", True);    break; /* (1 << 20) */
        case FALLRANGE_CONVEX_STATE:    STSDBG_WR_STR("[FALLRANGE_CONVEX_STATE]", True);   break; /* (2 << 20) */
        case FALLRANGE_CONCAVE_STATE:   STSDBG_WR_STR("[FALLRANGE_CONCAVE_STATE]", True);  break; /* (3 << 20) */
        case FALLRANGE_PRE_READY_STATE: STSDBG_WR_STR("[FALLRANGE_PRE_READY_STATE]", True);break; /* (4 << 20) */
        case FALLRANGE_READY_STATE:     STSDBG_WR_STR("[FALLRANGE_READY_STATE]", True);    break; /* (5 << 20) */
        /* SYMB RATE BIN FSM */
        case SRBIN_RESET_STATE:         STSDBG_WR_STR("[SRBIN_RESET_STATE]", True);        break; /* (1 << 24) */
        case SRBIN_NEXT_CHANNEL_STATE:  STSDBG_WR_STR("[SRBIN_NEXT_CHANNEL_STATE]", True); break; /* (2 << 24) */
        case SRBIN_NEXT_BIN_STATE:      STSDBG_WR_STR("[SRBIN_NEXT_BIN_STATE]", True);     break; /* (3 << 24) */
        case SRBIN_LOCK_TEST_STATE:     STSDBG_WR_STR("[SRBIN_LOCK_TEST_STATE]", True);    break; /* (4 << 24) */
        case SRBIN_CLEANUP_STATE:       STSDBG_WR_STR("[SRBIN_CLEANUP_STATE]", True);      break; /* (5 << 24) */
        case SRBIN_READY_STATE:         STSDBG_WR_STR("[SRBIN_READY_STATE]", True);        break; /* (6 << 24) */   
        /* POWER SCAN FSM */
        case PWRSCAN_RESET_STATE:	    STSDBG_WR_STR("[PWRSCAN_RESET_STATE]", True);      break; /* (1 << 28) */
        case PWRSCAN_TUNE_STATE:        STSDBG_WR_STR("[PWRSCAN_TUNE_STATE]", True);       break; /* (2 << 28) */
        case PWRSCAN_START_STATE:  	    STSDBG_WR_STR("[PWRSCAN_START_STATE]", True);      break; /* (3 << 28) */
        case PWRSCAN_STEP_STATE: 		STSDBG_WR_STR("[PWRSCAN_STEP_STATE]", True);       break; /* (4 << 28) */
        case PWRSCAN_STOP_STATE:        STSDBG_WR_STR("[PWRSCAN_STOP_STATE]", True);       break; /* (5 << 28) */
        case PWRSCAN_READY_STATE:       STSDBG_WR_STR("[PWRSCAN_READY_STATE]", True);      break; /* (6 << 28) */   
        case PWRSCAN_ABORT_STATE:       STSDBG_WR_STR("[PWRSCAN_ABORT_STATE]", True);      break; /* (7 << 28) */

        default:STSDBG_WR_STR("[UNDEFINED STATE]", True); break;
    }
#endif /* HAMARO_WIN_DEBUG */
}

/*****************************************************************************/
/* DEBUG_CheckFSMLimits() */
/*   */
/*****************************************************************************/
STATE* 
DEBUG_CheckFSMLimits(STATE* curr_state)
{
    DEBUG_StateCode2String(curr_state->coding);

	if ((curr_state->coding & (DEBUG_GetFSMLimits())) != 0)
	{
		return &idle_state;
	}
	return curr_state;
}

#endif /* HAMARO_INCLUDE_DEBUG */

#endif /* HAMARO_SCAN_THE_SKY */