hamaro_pwrscan.c

QPSK Tuner details, for conexant chipset.

    {
        STSDBG_WR_INT_LN("Write failed for frequency count = ", addr);
        return (False);
    }
    return (True);
}

/*****************************************************************************/
/* PWRSCAN_GetTotalFreqOffset() */
/*****************************************************************************/
static int
PWRSCAN_GetTotalFreqOffset(int center_frequency, int frequency_step)
{
    int total_freq_offset;

    total_freq_offset = center_frequency - frequency_step;
#if STS_ENABLE_VERBOSE_LOG
    STSDBG_WR_INT(" | Center = ", center_frequency);
    STSDBG_WR_INT(" | Step size = ", frequency_step);
    STSDBG_WR_INT(" | Center + step_size = ", total_freq_offset);
#endif /* STS_ENABLE_VERBOSE_LOG */
    return (total_freq_offset);
}

/*****************************************************************************/
/* PWRSCAN_WriteFreqCount() */
/*****************************************************************************/
static BOOL
PWRSCAN_WriteFreqCount(unsigned short value)
{
    if (STS_WRITE(STS_FREQ_CNT, value) == False) 
    {
        return (False);
    }
    return (True);
}

/*****************************************************************************/
/* PWRSCAN_GetInitialCenterFreq() */
/*****************************************************************************/
static int s_center_frequency;
static int
PWRSCAN_GetInitialCenterFreq(unsigned char span_mhz, int additional_offset)
{
    s_center_frequency = ((unsigned long)span_mhz * 1000000UL) / 2UL;
    s_center_frequency = (s_center_frequency + additional_offset); 
    
    return s_center_frequency;    
}
/*****************************************************************************/
/* PWRSCAN_GetNextCenterFreq() */
/*****************************************************************************/
static int
PWRSCAN_GetNextCenterFreq(unsigned short freq_count, unsigned long step_size_hz)
{
    s_center_frequency -= ((int)freq_count * (int)step_size_hz); /* next set */

    return s_center_frequency;
}

/*****************************************************************************/
/* PWRSCAN_GetInitialFreqStep() */
/*****************************************************************************/
static int s_initial_freq_step;
static int
PWRSCAN_GetInitialFreqStep(unsigned long step_size_hz, unsigned short number_freq_cnt)
{
    s_initial_freq_step = (step_size_hz * number_freq_cnt) >> 1;

    return -s_initial_freq_step; 
}

/*****************************************************************************/
/* PWRSCAN_GetReadyBitTimeout() */
/*   */
/*****************************************************************************/
static long window_length_lookup[STS_MAX_OBSERVATION_WINDOW_INDEX] = 
{
    0x200,    /* 2POW09 */
    0x400,    /* 2POW10 */
    0x800,    /* 2POW11 */
    0x1000,   /* 2POW12 */
    0x2000,   /* 2POW13 */
    0x4000,   /* 2POW14 */
    0x8000,   /* 2POW15 */
    0x10000,  /* 2POW16 */
    0x20000,  /* 2POW17 */
    0x40000,  /* 2POW18 */
    0x80000,  /* 2POW19 */
    0x100000, /* 2POW20 */
    0x200000, /* 2POW21 */
    0x400000, /* 2POW22 */
    0x800000, /* 2POW23 */
    0x1000000 /* 2POW24 */
};
static long 
PWRSCAN_GetReadyBitTimeout(unsigned short observation_window, unsigned long match_filter_clock_khz)
{
    long delay_msec, delay_buffer;

    if (observation_window > (STS_MAX_OBSERVATION_WINDOW_INDEX-1))
    {
        return 0;
    }

    delay_msec   = (window_length_lookup[observation_window] / (long)match_filter_clock_khz) + 1L;
    
    delay_buffer = delay_msec / 20; /* 5% buffer */

    delay_msec = delay_msec + delay_buffer;
    
    /* STSDBG_WR_INT_LN("Ready bit timeout (msec) = ", delay_msec); */

    return (delay_msec);
}

static void 
PWRSCAN_Sleep(clock_t wait_msec)
{
   clock_t goal;

   goal = wait_msec + clock();
   while( goal > clock() )
   { /* loop until timeout */
   }
}

/*****************************************************************************/
/* PWRSCAN_WaitForMeasurement() */
/*   */
/*****************************************************************************/
static long delay = 0;
static BOOL
PWRSCAN_WaitForMeasurement()
{   
    unsigned short read_count;
    int  forever = 1;
#if HAMARO_WIN_DEBUG
    unsigned short read_val1 = 0, read_val2 = 0; 
#endif /* HAMARO_WIN_DEBUG */
    if (STS_WRITE(STS_AUTO_MODE, 0) == False)
    {
        return (False);
    }

    /* Wait for STS ready (STS Page=0, Add=0x05) */
    read_count = 0;
    do {
        delay = PWRSCAN_GetReadyBitTimeout(s_power_scan_data.power_scan_input.observation_window, s_power_scan_data.power_scan_input.symbol_rate_khz);
        
        PWRSCAN_Sleep(delay);    
        
        PWRSCAN_CheckErrors(); 

#if HAMARO_WIN_DEBUG
        if (STS_READ(STS_LEN, &read_val1) == False) 
        {
            return (False);
        }

        if (STS_READ(STS_LEN_SEL, &read_val2) == False) 
        {
            return (False);
        }

        if (s_power_scan_data.power_scan_input.observation_window != read_val2)
        {
            STSDBG_WR_UNSIGNED("ERROR: STS_LEN_SEL = ", read_val2);
            STSDBG_WR_UNSIGNED_LN(" does not match programmed value = ", s_power_scan_data.power_scan_input.observation_window);
        }
        if (read_val1 != read_val2)
        {
            STSDBG_WR_UNSIGNED("ERROR: STS_LEN_SEL = ", read_val2);
            STSDBG_WR_UNSIGNED_LN(" does not match STS_LEN = ", read_val1);
        }
#endif /* HAMARO_WIN_DEBUG */

        if (PWRSCAN_IsReady() == True)
        {
#if STS_ENABLE_VERBOSE_LOG
            STSDBG_WR_UNSIGNED("Total delay = ", delay);
            STSDBG_WR_UNSIGNED(" x ", read_count+1);
            STSDBG_WR_STR(" times ", True);
#endif /* STS_ENABLE_VERBOSE_LOG */
            break;
        }

        if (read_count == STS_WAIT_FOR_MEASUREMENT_TIMEOUT)
        {
            STSDBG_WR_STR("PWRSCAN_WaitForMeasurement::STS_WAIT_FOR_MEASUREMENT_TIMEOUT", True);
            return (False);
        }
        read_count++;
    } while (forever);

    return (True);
}

/* Power Scan: Reset state */
extern unsigned short s_max_raw_power_reading;
extern unsigned short s_sub_max_raw_power_reading;

static void   
PWRSCAN_ResetEnter()
{
    unsigned long symbol_rate_mhz;
    unsigned long step_size_khz;

    s_power_scan_data.delta_abs_freq_khz = 0;
    s_power_scan_data.b_last_set = False;
    s_power_scan_data.forever = 1;

    p_power_reading = 0;
    p_freq_reading  = 0;
    p_filled_buffer_length = 0;

    s_power_scan_data.b_abort = False;
    s_continue_scan = False;
    s_stop = False;

    symbol_rate_mhz = s_power_scan_data.power_scan_input.symbol_rate_khz/1000;
    if (symbol_rate_mhz < STS_MIN_MATCH_FILTER_CLK_MHZ)
    {
        s_power_scan_data.power_scan_input.symbol_rate_khz = STS_MIN_MATCH_FILTER_CLK_MHZ * 1000;
    }
    else if (symbol_rate_mhz > STS_MAX_MATCH_FILTER_CLK_MHZ)
    {
        s_power_scan_data.power_scan_input.symbol_rate_khz = STS_MAX_MATCH_FILTER_CLK_MHZ * 1000;
    }

    step_size_khz   = s_power_scan_data.power_scan_input.step_size_hz/1000;
    if (step_size_khz < STS_MIN_STEP_SIZE_KHZ) /* cannot do steps less than 10khz */
    {
        s_power_scan_data.power_scan_input.step_size_hz = STS_MIN_STEP_SIZE_KHZ * 1000;
    }
    else if (step_size_khz > STS_MAX_STEP_SIZE_KHZ) /* 1Mhz. */
    {
        s_power_scan_data.power_scan_input.step_size_hz = STS_MAX_STEP_SIZE_KHZ * 1000;
    }

    s_power_scan_data.number_freq_cnt = PWRSCAN_GetNumFreqCount((unsigned char)(s_power_scan_data.power_scan_input.symbol_rate_khz/1000), 
                                                                (unsigned short)(s_power_scan_data.power_scan_input.step_size_hz/1000));

    if (STS_GetUseMainBuffer() == True)
    {
        p_power_reading = &s_power_spectrum_data.power[0]; 
        p_freq_reading  = &s_power_spectrum_data.abs_freq[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_buffer_len;
        s_power_scan_data.max_index = STS_MAX_INDEX;
        p_max_pwr_reading = &s_max_raw_power_reading;
        p_agcacc = &s_power_spectrum_data.agcacc;
    }
    else
    {
        p_power_reading = &s_power_spectrum_data.sub_power[0]; 
        p_freq_reading  = &s_power_spectrum_data.sub_abs_freq[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_sub_buffer_len;
        s_power_scan_data.max_index = STS_MAX_SUB_INDEX;
        p_max_pwr_reading = &s_sub_max_raw_power_reading;
        p_agcacc = &s_power_spectrum_data.sub_agcacc;
    }

    if (s_power_scan_data.power_scan_input.search_span_mhz > STS_MAX_SPAN_MHZ)
    {
        s_power_scan_data.power_scan_input.search_span_mhz = STS_MAX_SPAN_MHZ;
    }

    s_power_scan_data.max_number_of_sets = PWRSCAN_GetMaxNumberSets(s_power_scan_data.power_scan_input.search_span_mhz, 
                                                                    s_power_scan_data.number_freq_cnt, 
                                                                    s_power_scan_data.power_scan_input.step_size_hz);  

    PWRSCAN_ResetBuffers();

    if (s_power_scan_data.number_freq_cnt > STS_MAX_FREQ_MEM_REGISTERS) /* max registers */ 
    {
        s_power_scan_data.b_abort = True;
        return;
    }

    if (s_power_scan_data.power_scan_input.search_span_mhz % 2)
    {
        s_power_scan_data.power_scan_input.search_span_mhz++;
    }

    PWRSCAN_ProgramPLLMult(STS_PLL_MULT);

    /* 3)  Set symbol rate */
    HAMARO_SetSymbolRate(hamaro_nim_list.nim[0], s_power_scan_data.power_scan_input.symbol_rate_khz);

    PWRSCAN_Enable(True); 
}


static BOOL   
PWRSCAN_Reset2TuneCriterion()
{
    return (True);
}

static STATE* 
PWRSCAN_Reset2Tune()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_tune_state);
	return &pwrscan_tune_state;
}

static BOOL   
PWRSCAN_Reset2AbortCriterion()
{
    if (s_power_scan_data.b_abort == True)
    {
        return (True);
    }
    return (False);
}

static STATE* 
PWRSCAN_Reset2Abort()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_abort_state);
	return &pwrscan_abort_state;
}


/* Power scan: Tune state */
static void   
PWRSCAN_TuneEnter()
{    
    s_power_scan_data.number_of_segments++;

    if (s_power_scan_data.power_scan_input.tuner_freq_hz > SCAN_HIGH_LIMIT) 
    {
        s_power_scan_data.b_last_set = True;
        return;
    }

    s_power_scan_data.power_scan_input.tuner_freq_hz += ((unsigned long)s_power_scan_data.power_scan_input.search_span_mhz * 1000000UL) >> 1UL; 

    if (s_power_scan_data.power_scan_input.tuner_freq_hz < SCAN_LOW_LIMIT)
    {
        s_power_scan_data.b_abort = True;
        return;
    }

    /* 1)  For channel sensing, we need to open the tuner anti-alias filter to maximum. */
    /* Anti-alias Filter Bandwidth = Acquisition Freq Offset + roll-off * Symbol Rate   */
    if (s_power_scan_data.power_scan_input.bw_symbol_rate_mhz > STS_MAX_SYMBOL_RATE_MHZ)
    {
        s_power_scan_data.power_scan_input.bw_symbol_rate_mhz = STS_MAX_SYMBOL_RATE_MHZ;
    }

    if (s_power_scan_data.power_scan_input.bw_symbol_rate_mhz == STS_MAX_SYMBOL_RATE_MHZ) /* open max bandwidth */
    {
        PWRSCAN_OpenBandwidth(675UL, STS_MAX_SYMBOL_RATE_MHZ*1000UL, 5000L);
    }
    else
    {
        PWRSCAN_OpenBandwidth(675UL, (unsigned long)(s_power_scan_data.power_scan_input.bw_symbol_rate_mhz)*1000UL, 0L);
    }    

    PWRSCAN_AAGCControl(False); /* normal operation */

    s_power_scan_data.pll_lock = 0;
    s_power_scan_data.actual_tuner_frequency = 0;

    /* 4)  Set Tuner frequency */
    PWRSCAN_SetTunerFrequency(s_power_scan_data.power_scan_input.tuner_freq_hz, 
                             &s_power_scan_data.pll_lock, 
                             &s_power_scan_data.actual_tuner_frequency);

    s_power_scan_data.tuner_freq_khz = (int)(s_power_scan_data.power_scan_input.tuner_freq_hz/1000);
}

static BOOL   
PWRSCAN_Tune2AbortCriterion()
{
    if (s_power_scan_data.b_abort == True)
    {
        return (True);
    }
    return (False);
}

static STATE* 
PWRSCAN_Tune2Abort()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_abort_state);
	return &pwrscan_abort_state;
}

static BOOL   
PWRSCAN_Tune2StartCriterion()
{
    return (True);
}