hamaro_sdc.c

QPSK Tuner details, for conexant chipset.

/* STS_GetUseMainBuffer() */
/*****************************************************************************/
BOOL 
STS_GetUseMainBuffer()
{
    return (s_power_spectrum_data.b_use_main);
}


/* DEBUG only */
static unsigned char format = 1;
void STS_SetPowerSpectrumLogFormat(unsigned char format_value)
{
    format = format_value;
}

/*****************************************************************************/
/* STS_LogPowerSpectrum() - this is DEBUG only */
/*****************************************************************************/
void 
STS_LogPowerSpectrum()
{
    unsigned long*  p_freq_reading = 0;
    unsigned short* p_filled_buffer_length = 0;
    unsigned short* p_power_reading = 0;
    short loop;

    if (STS_GetUseMainBuffer() == True)
    {
        p_freq_reading = &s_power_spectrum_data.abs_freq[0]; 
        p_power_reading = &s_power_spectrum_data.power[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_buffer_len;
    }
    else
    {
        p_freq_reading = &s_power_spectrum_data.sub_abs_freq[0];         
        p_power_reading = &s_power_spectrum_data.sub_power[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_sub_buffer_len;
    }

    if (format == 1)
    {
        for (loop=0; loop < *p_filled_buffer_length-1; loop++)
        {
            STSDBG_WR_UNSIGNED_LN("[Absolute freq hz] = ", (int)p_freq_reading[loop]);
            STSDBG_WR_UNSIGNED_LN("[Power measurement] = ", (int)p_power_reading[loop]);
            STSDBG_WR_INT_LN("[AAGC] = ", PWRSCAN_GetAGCFromFreq(p_freq_reading[loop]));
        }
    }
    else if (format == 2)
    {
        for (loop=0; loop < *p_filled_buffer_length-1; loop++)
        {
            STSDBG_WR_UNSIGNED_LN("freq1(hz) = ", (int)p_freq_reading[loop]);
            STSDBG_WR_UNSIGNED_LN("Power1 = ", (int)p_power_reading[loop]);
        }
    }
    else if (format == 3)
    {
        for (loop=0; loop < *p_filled_buffer_length-1; loop++)
        {
            STSDBG_WR_UNSIGNED_LN("freq2(hz) = ", (int)p_freq_reading[loop]);
            STSDBG_WR_UNSIGNED_LN("Power2 = ", (int)p_power_reading[loop]);
        }
    }
    else /* format > 3 */
    {
        for (loop=0; loop < *p_filled_buffer_length-1; loop++)
        {
            STSDBG_WR_UNSIGNED_LN("[Processed Absolute freq hz] = ", (int)p_freq_reading[loop]);
            STSDBG_WR_UNSIGNED_LN("[Processed Power measurement] = ", (int)p_power_reading[loop]);
            STSDBG_WR_INT_LN("[Processed AAGC] = ", PWRSCAN_GetAGCFromFreq(p_freq_reading[loop]));
            STSDBG_WR_INT_LN("[Processed INDEX] = ", loop);
            STSDBG_WR_INT_LN("[Processed ADDR] = ", HWBUF_DEC_BUF0_ADDR+loop*2);
        }
    }
 }

/*****************************************************************************/
/* STS_LogMainPowerSpectrum() - this is DEBUG only */
/*****************************************************************************/
void 
STS_LogMainPowerSpectrum()
{
    short loop;

    for (loop = 0; loop < s_power_spectrum_data.filled_buffer_len; loop++)
    {
        STSDBG_WR_UNSIGNED_LN("[Absolute freq hz] = ", s_power_spectrum_data.abs_freq[loop]);
        STSDBG_WR_UNSIGNED_LN("[Power measurement] = ",s_power_spectrum_data.power[loop]);
    }
    STSDBG_WR_INT_LN("[AAGC] = ",s_power_spectrum_data.agcacc);        
 }


/*****************************************************************************/
/* STS_GetFirstFreq() */
/*****************************************************************************/
BOOL
STS_GetFirstFreq(unsigned long* p_first_freq)
{
    unsigned long*  p_freq_reading = 0;

    if (STS_GetUseMainBuffer() == True)
    {
        p_freq_reading = &s_power_spectrum_data.abs_freq[0]; 
    }
    else
    {
        p_freq_reading = &s_power_spectrum_data.sub_abs_freq[0]; 
    }

    if (p_first_freq)
    {
        *p_first_freq = p_freq_reading[0];
        STSDBG_WR_UNSIGNED_LN("First freq = ", p_freq_reading[0]);
        return (True);
    }
    return (False);
}

/*****************************************************************************/
/* STS_GetIndexFromFreq() - used for main buffer only */
/*****************************************************************************/
unsigned short
STS_GetIndexFromFreq(unsigned long freq)
{  
    short index = 0;
    unsigned short* p_filled_buffer_length = 0;
    unsigned long* p_freq_reading = 0;

    if (STS_GetUseMainBuffer() == True)
    {
        p_freq_reading = &s_power_spectrum_data.abs_freq[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_buffer_len;
        index = PWRSCAN_FindNearestStartIndex(freq);
        for (; index < *p_filled_buffer_length; index++)
        {
            if (freq <= p_freq_reading[index])
            {
                break;
            }
        }
    }
    return (unsigned short)(index);
}

/*****************************************************************************/
/* STS_GetPowerFromIndex() */
/*****************************************************************************/
unsigned short
STS_GetPowerFromIndex(unsigned short index)
{
    unsigned short* p_power_reading = 0;
    unsigned short* p_filled_buffer_length = 0;

    if (STS_GetUseMainBuffer() == True)
    {
        p_power_reading = &s_power_spectrum_data.power[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_buffer_len;
    }
    else
    {
        p_power_reading = &s_power_spectrum_data.sub_power[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_sub_buffer_len;
    }

    if (index > (*p_filled_buffer_length-1))
    {
        return (0);
    }

    return (p_power_reading[index]);
}

/*****************************************************************************/
/* STS_MeasurementIterInit() */
/*****************************************************************************/
static unsigned short s_iter = 0;
BOOL
STS_MeasurementIterInit(unsigned short start_index)
{
    unsigned short filled_buffer_length = 0;

    if (STS_GetUseMainBuffer() == True)
    {
        filled_buffer_length = s_power_spectrum_data.filled_buffer_len;       
    }
    else
    {
        filled_buffer_length = s_power_spectrum_data.filled_sub_buffer_len;
    }

    s_iter = 0;

    if (start_index != 0xFFFF) /* caller specified */
    {
        if (start_index < filled_buffer_length)
        {
            s_iter = start_index;
        }
    }
    return (True);
}

/*****************************************************************************/
/* STS_MeasurementIterNext() */
/* return True if move was made */
/*****************************************************************************/
BOOL
STS_MeasurementIterNext(unsigned short step)
{
    unsigned short filled_buffer_length = 0;

    if (STS_GetUseMainBuffer() == True)
    {
        filled_buffer_length = s_power_spectrum_data.filled_buffer_len;
    }
    else
    {
        filled_buffer_length = s_power_spectrum_data.filled_sub_buffer_len;
    }

    if (s_iter > (filled_buffer_length-1))
    {
        STSDBG_WR_STR ("[STS_MeasurementIterNext] OVERFLOW", True);
        return (False);
    }

    if (filled_buffer_length && ((filled_buffer_length-1) >= step))
    {
        if (s_iter < (filled_buffer_length-1-step))
        {
            s_iter = s_iter + step;
            return (True);
        }
    }
    return (False);
}

/*****************************************************************************/
/* STS_MeasurementIterPrev() */
/* return True if move was made */
/*****************************************************************************/
BOOL
STS_MeasurementIterPrev(unsigned short step)
{
    unsigned short filled_buffer_length = 0;

    if (STS_GetUseMainBuffer() == True)
    {
        filled_buffer_length = s_power_spectrum_data.filled_buffer_len;
    }
    else
    {
        filled_buffer_length = s_power_spectrum_data.filled_sub_buffer_len;
    }

    if (s_iter == 0)
    {
        STSDBG_WR_STR ("[STS_MeasurementIterPrev] UNDERFLOW", True);
        return (False);
    }

    if (filled_buffer_length && ((filled_buffer_length-1) >= step))
    {
        if (s_iter >= step)
        {
            s_iter = s_iter - step;
            return (True);
        }
    }
    return (False);
}


/*****************************************************************************/
/*****************************************************************************/
/* STS_PrintSamples */
/*  */
/*****************************************************************************/
static void
STS_PrintSamples(char* function_name)
{
    if (function_name == 0)
    {
        return;
    }

//    STSDBG_WR_STR(function_name, True);
//
//    STSDBG_WR_INT_LN("step = ", s_power_spectrum_data.s_sts_sample.step);
//    STSDBG_WR_UNSIGNED("f0 = ", *s_power_spectrum_data.s_sts_sample.p_freq[0]);
//    STSDBG_WR_UNSIGNED("f1 = ", *s_power_spectrum_data.s_sts_sample.p_freq[1]);
//    STSDBG_WR_UNSIGNED_LN("f2 = ", *s_power_spectrum_data.s_sts_sample.p_freq[2]);
//
//    STSDBG_WR_INT  ("p0 = ", *s_power_spectrum_data.s_sts_sample.p_power[0]);
//    STSDBG_WR_INT  ("p1 = ", *s_power_spectrum_data.s_sts_sample.p_power[1]);
//    STSDBG_WR_INT_LN("p2 = ", *s_power_spectrum_data.s_sts_sample.p_power[2]);
//    STSDBG_WR_STR("-----------------", True);
}

/*****************************************************************************/
/* STS_GetSamples */
/*  */
/*****************************************************************************/
HAMARO_STS_SAMPLE*
STS_GetSamples()
{
    STS_PrintSamples("STS_GetSamples");
    return &s_power_spectrum_data.s_sts_sample;
}


/*****************************************************************************/
/* STS_SetDoubleStep */
/*  */
/*****************************************************************************/
BOOL s_no_double_step = False;
void
STS_SetNoDoubleStep()
{
    s_no_double_step = True; 
}

/*****************************************************************************/
/* STS_ResetDoubleStep */
/*  */
/*****************************************************************************/
void
STS_ResetNoDoubleStep()
{
    s_no_double_step = False;
}

/*****************************************************************************/
/* STS_IsDoubleStep */
/*  */
/*****************************************************************************/
BOOL STS_GetNoDoubleStep()
{
    //return(s_no_double_step);
    return(True); 
}

/*****************************************************************************/
/* STS_SetStep */
/*  */
/*****************************************************************************/
void
STS_SetStep(unsigned short step)
{
    s_power_spectrum_data.s_sts_sample.step = step;
}


/*****************************************************************************/
/* STS_StartAllOver */
/* If start index = 0xFFFF, point to first sample in the buffer */
/*****************************************************************************/
void
STS_StartAllOver(unsigned short step, unsigned short start_index)
{
    unsigned short* p_power_reading = 0;
    unsigned long*  p_freq_reading = 0;

    if (STS_GetUseMainBuffer() == True)
    {
        p_power_reading = &s_power_spectrum_data.power[0]; 
        p_freq_reading  = &s_power_spectrum_data.abs_freq[0]; 
    }
    else
    {
        p_power_reading = &s_power_spectrum_data.sub_power[0]; 
        p_freq_reading  = &s_power_spectrum_data.sub_abs_freq[0]; 
    }

    STS_MeasurementIterInit(start_index);
    s_power_spectrum_data.s_sts_sample.step = step;

    s_power_spectrum_data.s_sts_sample.p_freq[0] = &p_freq_reading[s_iter];
    s_power_spectrum_data.s_sts_sample.p_freq[1] = &p_freq_reading[s_iter+step];    
    s_power_spectrum_data.s_sts_sample.p_freq[2] = &p_freq_reading[s_iter+step*2];

    s_power_spectrum_data.s_sts_sample.p_power[0] = &p_power_reading[s_iter];
    s_power_spectrum_data.s_sts_sample.p_power[1] = &p_power_reading[s_iter+step];
    s_power_spectrum_data.s_sts_sample.p_power[2] = &p_power_reading[s_iter+step*2];
    
    STS_ResetNoDoubleStep();

    STS_PrintSamples("--STS_StartAllOver");
}