hamaro_sdc.c

QPSK Tuner details, for conexant chipset.

static void   
STS_RescanEnter()
{
}

static BOOL   
STS_Rescan2ResetCriterion()
{
    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;
}

unsigned short
STS_GetMaxMainBufferLength()
{
    return s_power_spectrum_data.filled_buffer_len;
}

static void  
STS_ReadyEnter()
{
    if (s_abs_right_inflection_point_hz > s_abs_left_inflection_point_hz)
    {
        s_symbol_rate_hz  = s_abs_right_inflection_point_hz - s_abs_left_inflection_point_hz;
                
        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;
        if (s_symbol_rate_hz>MAX_SYMBOL_RATE)
            s_symbol_rate_hz = MAX_SYMBOL_RATE;
        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::F1  (Hz) = ", s_current_sd->f1);
        STSDBG_WR_UNSIGNED_LN("STS FSM::F2  (Hz) = ", s_current_sd->f2);
        STSDBG_WR_UNSIGNED_LN("STS FSM::Left  (Hz) = ", s_abs_left_inflection_point_hz);
        STSDBG_WR_UNSIGNED_LN("STS FSM::Right (Hz) = ", s_abs_right_inflection_point_hz);
        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; 
    }
    s_current_tp_index++;
}


static BOOL  
STS_Ready2SRBinCriterion()
{

    FSM_Poll(&bin_search_fsm); 

    if ( ((FSM_CheckState(&bin_search_fsm, BINSEARCH_READY_STATE) == True) && 
                            (STS_GetEdge() == STS_EDGE_UNKNOWN)) ||
                ((FSM_CheckState(&bin_search_fsm, FSM_IDLE_STATE) == True) && 
                            (STS_GetEdge() == STS_EDGE_RISING)) )               
//  if ( (FSM_CheckState(&bin_search_fsm, BINSEARCH_READY_STATE) == True) && (STS_GetEdge() == STS_EDGE_UNKNOWN) )
  {
            s_current_sd = GetCandidateNextAdv(g_tp_data0, s_counts, s_current_tp_index);
            if (s_current_sd==NULL)
            {
        /* 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);
        FSM_Init(&pwr_scan_fsm);
        
        STS_Cleanup();
        STS_UpdateProgress(HAMARO_STS_CHANNEL_EXTRACTION);      
        STSDBG_WR_ELAPSED_TIME(); 
            return (True);
            }
    }

    return (False);
}

static STATE* 
STS_Ready2SRBin()
{
    return &sts_srbin_state;
}

static BOOL   
STS_Ready2BinarySearchCriterion()
{
    /************************************************
    If there are still candidate transponders available in the array, return True.
    Otherwise, return False.
    *************************************************/
    FSM_Poll(&bin_search_fsm);
    if ( ((FSM_CheckState(&bin_search_fsm, BINSEARCH_READY_STATE) == True) && 
                            (STS_GetEdge() == STS_EDGE_UNKNOWN)) ||
                ((FSM_CheckState(&bin_search_fsm, FSM_IDLE_STATE) == True) && 
                            (STS_GetEdge() == STS_EDGE_RISING)) )           
    {
        s_current_sd = GetCandidateNextAdv(g_tp_data0, s_counts, s_current_tp_index);
        if (s_current_sd != NULL)
        {
            FSM_Init(&bin_search_fsm);
            STS_SetEdge(STS_EDGE_RISING); 
//            p_find_rise_range_curvature->concave = s_current_sd->f1;
//            p_find_rise_range_curvature->convex = s_current_sd->f1 + DEFAULT_EDGE_RANGE;
            return True;
        }
    }
  
  return False;
}

static STATE* 
STS_Ready2BinarySearch()
{
    DBG_CHECK_FSM_LIMITS(&sts_binary_search_state);    
    STSDBG_WR_STR("<<<<<<<<<< BINARYSEARCH NEXT CANDIDATE >>>>>>>>>>", True);
    return &sts_binary_search_state; 
}




/* scan SR binning state */
static void  
STS_SRBinEnter()
{
    /* Fine tune the channel parameters */
    STS_StartSRBinning();
    SRBIN_Start(&sr_bin_fsm);
}

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

static BOOL   
STS_SRBin2CompleteState()
{    
    if (FSM_CheckState(&sr_bin_fsm, SRBIN_READY_STATE) == True)
    {
        FSM_Init(&sr_bin_fsm);
        FSM_Init(&sts_fsm);
        STS_Cleanup();
        STS_UpdateProgress(HAMARO_STS_COMPLETE);
        return (True);
    }
    return (False);
}

static STATE* 
STS_SRBin2Complete()
{
    DBG_CHECK_FSM_LIMITS(&sts_complete_state);    
    return &sts_complete_state; 
}

/* Complete state */
static void  
STS_CompleteEnter()
{
    /* do nothing */
}

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

    return (True);
}

/*static*/ void
STSDBG_FileClose()
{
    STSDBG_WR_STR("==========================================\n- Done - ", True);
    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();
    STSDBG_FileOpen();
#endif /* HAMARO_WIN_DEBUG */

    STS_SetUseMainBuffer(True);

    return (True);
}


/*****************************************************************************/
BOOL
STS_Release()
{
#if HAMARO_WIN_DEBUG
    WINDBG_FileClose(); 
#endif /* HAMARO_WIN_DEBUG */
    STS_Cleanup();
    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_ChangeChannel() */
/*   */
/*****************************************************************************/
BOOL      
STS_ChangeChannel(HAMARO_CHANOBJ* p_channel_object)
{
      //HAMARO_AcqBegin(hamaro_nim_list.nim[0]);
      HAMARO_ClearPendingInterrupts(hamaro_nim_list.nim[0]);
    if (HAMARO_ChangeChannel(hamaro_nim_list.nim[0], p_channel_object) == False)
    {
        return (False);
    }
    return (True);
}

/*****************************************************************************/
/* STS_GetLockIndicators() */
/*   */
/*****************************************************************************/
BOOL      
STS_GetLockIndicators(HAMARO_LOCKIND* p_lockinds)
{
    if (p_lockinds == 0)
    {
        return (False);
    }

    if (HAMARO_GetLockIndicators(hamaro_nim_list.nim[0], p_lockinds) == False)
    {
        return (False);
    }
    return (True);
}


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

/*****************************************************************************/
/* STS_UseBuffer() */
/*****************************************************************************/
void 
STS_SetUseMainBuffer(BOOL b_use_main)
{
    s_power_spectrum_data.b_use_main = b_use_main;
}

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