hamaro_sts.c

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

        FSM_Init(&rise_range_fsm); /* IDLE state */
        STSDBG_WR_STR("STS FSM::RiseRange FSM is DISABLED", True);
		return True; /* transit to sts_binary_search_state in corresponding exit task */
	}
	return False; /* stay in this state */
}

/*****************************************************************************/
/* STS_RisingEdge2BinarySearch() */
/*   */
/*****************************************************************************/
static STATE*
STS_RisingEdge2BinarySearch()
{
    DBG_CHECK_FSM_LIMITS(&sts_binary_search_state);
	return &sts_binary_search_state;
}

/* fall edge state */
static void  
STS_FallingEdgeEnter()
{
    STS_SetUseMainBuffer(True); /* Switch back to main buffer */
    FSM_Init(&fall_edge_fsm);
    FALLEDGE_Start(&fall_edge_fsm);
    STSDBG_WR_STR("STS FSM::FallEdge FSM is STARTED", True);
}

static void  
STS_FallingEdge() /* Routine task */
{
    FSM_Poll(&fall_edge_fsm);
	if (FSM_CheckState(&fall_edge_fsm, FALLEDGE_READY_STATE) == True)
    {        
        FSM_Init(&fall_edge_fsm); /* IDLE state */
        STSDBG_WR_STR("STS FSM::FallEdge FSM is DISABLED", True);
        FSM_Init(&fall_range_fsm);
        STS_SetEdge(STS_EDGE_FALLING); // REVISIT : added. Nov 22.
        FALLRANGE_Start(&fall_range_fsm);
        STSDBG_WR_STR("STS FSM::FallRange FSM is STARTED", True);
    }
}

static BOOL  
STS_FallingEdge2BinarySearchCriterion(unsigned long timeout)
{
	timeout = 0; /* not used */
    FSM_Poll(&fall_range_fsm);
	if (FSM_CheckState(&fall_range_fsm, FALLRANGE_READY_STATE) == True)
	{
        //STS_SetEdge(STS_EDGE_FALLING); // REVISIT
        FSM_Init(&fall_range_fsm); /* IDLE state */
        STSDBG_WR_STR("STS FSM::FallRange FSM is DISABLED", True);
		return True; /* transit to sts_binary_search_state in corresponding exit task */
	}
	return False; /* stay in this state */
}

static STATE* 
STS_FallingEdge2BinarySearch()
{
    DBG_CHECK_FSM_LIMITS(&sts_binary_search_state);
	return &sts_binary_search_state;
}


/* binary search state */
static void  
STS_BinarySearchEnter()
{
    FSM_Init(&bin_search_fsm);
    BINSRCH_Start(&bin_search_fsm);
    STSDBG_WR_STR("STS FSM::BinSearch FSM is STARTED", True);
}

static BOOL  
STS_BinarySearch2ReadyCriterion(unsigned long timeout)
{
    timeout = 0;
    FSM_Poll(&bin_search_fsm);
	if ( (FSM_CheckState(&bin_search_fsm, BINSEARCH_READY_STATE) == True) && (STS_GetEdge() == STS_EDGE_FALLING) )
    {        
        FSM_Init(&bin_search_fsm); /* IDLE state */
        STSDBG_WR_STR("STS FSM::BinSearch FSM is DISABLED", True);
        s_abs_right_inflection_point_hz = BINSRCH_GetInflectionPoint();
        STSDBG_WR_UNSIGNED_LN("STS FSM::s_abs_right_inflection_point_hz = ", s_abs_right_inflection_point_hz);
        return (True);
    }
    return (False);
}

static STATE* 
STS_BinarySearch2Ready()
{
    DBG_CHECK_FSM_LIMITS(&sts_ready_state);
	return &sts_ready_state;
}

static BOOL  
STS_BinarySearch2FallingEdgeCriterion(unsigned long timeout)
{
    timeout = 0;
    FSM_Poll(&bin_search_fsm);
	if ( (FSM_CheckState(&bin_search_fsm, BINSEARCH_READY_STATE) == True) && (STS_GetEdge() == STS_EDGE_RISING) )
    {        
        FSM_Init(&bin_search_fsm); /* IDLE state */
        STSDBG_WR_STR("STS FSM::BinSearch FSM is DISABLED", True);
        s_abs_left_inflection_point_hz = BINSRCH_GetInflectionPoint();
        STSDBG_WR_UNSIGNED_LN("STS FSM::s_abs_left_inflection_point_hz = ", s_abs_left_inflection_point_hz);
        return (True);
    }
    return (False);
}

static STATE*
STS_BinarySearch2FallingEdge()
{
    DBG_CHECK_FSM_LIMITS(&sts_falling_edge_state);
	return &sts_falling_edge_state;
}


/* rescan state */
static void   
STS_RescanEnter()
{
}

static BOOL   
STS_Rescan2ResetCriterion(unsigned long timeout)
{
    timeout = 0;
    return (True);
}

static STATE* 
STS_Rescan2Reset()
{
    DBG_CHECK_FSM_LIMITS(&sts_reset_state);
    STSDBG_WR_STR("<<<<<<<<<< RE-SCANNING CHANNEL >>>>>>>>>>", True);
	return &sts_reset_state;
}

/* ready state */
unsigned long
STS_GetLeftInflectionPoint() /* Frequency in Hz */
{
    return s_abs_left_inflection_point_hz;
}

unsigned long
STS_GetRightInflectionPoint() /* Frequency in Hz */
{
    return s_abs_right_inflection_point_hz;
}

static void  
STS_ReadyEnter()
{
    if (s_rescan == False)
    {
        s_symbol_rate_hz  = s_abs_right_inflection_point_hz - s_abs_left_inflection_point_hz;

        if (s_symbol_rate_hz > 17000000 && s_symbol_rate_hz < 23000000) /* TESTING */
        {
            s_symbol_rate_hz = 20000000;
        }

        s_carrier_freq_hz = (s_abs_right_inflection_point_hz + s_abs_left_inflection_point_hz) >> 1;

        s_sts_channel_info[s_channel_info_index].carrier_freq_hz = s_carrier_freq_hz;
        s_sts_channel_info[s_channel_info_index].symbol_rate_hz  = s_symbol_rate_hz;
        s_sts_channel_info[s_channel_info_index].code_rate = 0x0;
        s_sts_channel_info[s_channel_info_index].good_channel = False;

        s_channel_info_index++;

        STSDBG_WR_UNSIGNED_LN("STS FSM::Transponder SR(Hz) = ", s_symbol_rate_hz);
        STSDBG_WR_UNSIGNED_LN("STS FSM::Transponder CF(Hz) = ", s_carrier_freq_hz);
        b_channel_found = True; 
    }
}

static BOOL  
STS_Ready2ResetCriterion(unsigned long timeout)
{
    timeout = 0;
    if (b_channel_found == True)
    {
        return (True);
    }
    return (False);
}

static STATE*
STS_Ready2Reset()
{
    b_first_channel = False;
    DBG_CHECK_FSM_LIMITS(&sts_reset_state);
    STSDBG_WR_STR("<<<<<<<<<< SEARCHING NEXT CHANNEL >>>>>>>>>>", True);
	return &sts_reset_state;
}

static unsigned long s_freq_limit;
static BOOL  
STS_Ready2CompleteCriterion(unsigned long timeout)
{
    unsigned long last_freq;
    timeout = 0;
    
    if (STS_GetLastFreq(&last_freq) == False)
    {
        return (False);
    }

    if (last_freq >= s_freq_limit)
    {
        /* Disable all FSMs (other than SR binning */
        FSM_Init(&rise_edge_fsm);
        FSM_Init(&rise_range_fsm);
        FSM_Init(&fall_edge_fsm);
        FSM_Init(&fall_range_fsm);
        FSM_Init(&bin_search_fsm);
    
        return(True);
    }
    return (False);
}

static STATE* 
STS_Ready2Complete()
{
    return &sts_complete_state;
}

/* scan complete state */
static void  
STS_CompleteEnter()
{
    /* Fine tune the channel parameters */
    SRBIN_Start(&sr_bin_fsm);
}

static void  
STS_Complete()
{
    FSM_Poll(&sr_bin_fsm);
}

/*****************************************************************************/
/********************* Common functions **************************************/
/*****************************************************************************/
static BOOL
STSDBG_FileOpen()
{
#if HAMARO_WIN_DEBUG
    if (WINDBG_FileInit("C:\\dev\\Hamaro\\Software\\src\\Driver\\testlog.txt") == False)
    {
        return False;
    }
#endif /* HAMARO_WIN_DEBUG */
    STSDBG_WR_STR("- Scan-the-sky log - ", True);

    return (True);
}

static void
STSDBG_FileClose()
{
    STSDBG_WR_STR("==========================================\n- Done - ", True);
#if HAMARO_WIN_DEBUG
    WINDBG_FileClose();
#endif /* HAMARO_WIN_DEBUG */
}
/*****************************************************************************/
/* STS_Init()                                                                */
/*                                                                           */
/*****************************************************************************/
BOOL 
STS_Init (HAMARO_READ_SB  p_sb_read, HAMARO_WRITE_SB p_sb_write)
{
    if (p_sb_read == 0 || p_sb_write == 0)
    {
        return (False);
    }

    hamaro_sts_data.p_read  = p_sb_read;
    hamaro_sts_data.p_write = p_sb_write;

#if HAMARO_WIN_DEBUG
    WINDBG_FileClose();
#endif /* HAMARO_WIN_DEBUG */

    STSDBG_FileOpen();

    STS_SetUseMainBuffer(True);

    return (True);
}

/*****************************************************************************/
BOOL
STS_Release()
{
#if HAMARO_WIN_DEBUG
    WINDBG_FileClose(); 
#endif /* HAMARO_WIN_DEBUG */
    return (True);
}

/*****************************************************************************/
/* STS_RegRead()                                                             */
/*                                                                           */
/*****************************************************************************/
BOOL 
STS_RegRead(unsigned char   page, 
            unsigned short  address, 
            unsigned short  offset,
            unsigned char   start_bit, 
            unsigned char   num_bit, 
            unsigned short* p_data)
{
    unsigned long sts_register_options = 0;
    unsigned long read_mask = ( ((1UL << num_bit) - 1UL) << (unsigned long)start_bit ); 
    unsigned long iostatus;
    unsigned long read_value;

    if (hamaro_sts_data.p_read == 0)
    {
        return (False);
    }

    if (p_data == 0)
    {
        return (False);
    }

    sts_register_options = STS_APPLY_BASE_ADDRESS;
    sts_register_options |= (sts_register_options | ((unsigned long)page << STS_PAGE_NUMBER_SHIFT));

    read_value = hamaro_sts_data.p_read(sts_register_options, (unsigned char)(address+offset), &iostatus);

	if (iostatus != 0UL)
	{
		return (False);
	}

    *p_data = (unsigned short)((read_value & read_mask) >> (unsigned long)start_bit);

    return (True);
}


/*****************************************************************************/
/* STS_RegWrite() */
/*   */
/*****************************************************************************/
BOOL 
STS_RegWrite(unsigned char  page, 
             unsigned short address, 
             unsigned short offset,
             unsigned char  start_bit, 
             unsigned char  num_bit, 
             BOOL           rmw, 
             unsigned char  access,
             unsigned short data)
{
    unsigned long sts_register_options = 0;
    unsigned short mask = (unsigned short)( ((1UL << num_bit) - 1UL) << (unsigned long)start_bit ); 
    unsigned short value = data;
    unsigned long iostatus;

    if (hamaro_sts_data.p_write == 0) 
    {
        return (False);
    }

    if ((access & STS_REG_WRITEABLE) == 0) /* read-only */
    { /* WRITE ATTEMPTED ON READ-ONLY BITFIELD */
        return (True);
    }

    if (rmw == True)
    {
        if (STS_RegRead(page, address, offset, start_bit, num_bit, &value) == False)
        {
            return (False);
        }
        value &= ~(mask);
        value |= ((data << start_bit) & mask);
    }

    sts_register_options = STS_APPLY_BASE_ADDRESS;
    sts_register_options |= (sts_register_options | ((unsigned long)page << STS_PAGE_NUMBER_SHIFT));

    hamaro_sts_data.p_write(sts_register_options, (unsigned char)(address+offset), value, &iostatus);

	if (iostatus != 0UL)
	{
		return (False);
	}

    return (True);
}


/*****************************************************************************/
/* STS_ErrorClear() */
/*****************************************************************************/
static BOOL
STS_ErrorClear()
{
    if (STS_WRITE(STS_ERR_CLR, 1) == False)
    {
        return (False);
    }
#if (HAMARO_WIN_DEBUG & STS_ENABLE_SENSE_CHANNEL_TRACE)
     STSDBG_WR_STR("STS Error Clear = 1", True);
#endif /* HAMARO_WIN_DEBUG */
    return (True);
}

/*****************************************************************************/
/* STS_CheckErrors() */