hamaro_sts.c

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

/*****************************************************************************/
/* STS_ChangeChannel() */
/*   */
/*****************************************************************************/
BOOL      
STS_ChangeChannel(HAMARO_CHANOBJ* p_channel_object)
{
    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_WaitForMeasurement() */
/*   */
/*****************************************************************************/
static BOOL
STS_WaitForMeasurement()
{   
    unsigned short read_count;
    int  forever = 1;
//    unsigned short read_value;
    //unsigned short delay;

        //// REVISIT
        //STS_Enable(True);
        
        //STS_EmptyFifo();
        //STS_ErrorClear();
        //STS_CheckErrors();
        //// REVISIT

    if (STS_WRITE(STS_AUTO_MODE, 0) == False)
    {
        return (False);
    }

    /* 9)  Wait for STS ready (STS Page=0, Add=0x05) */
    read_count = 0;
    do {
       // if (STS_READ(STS_BUSY, &read_value) == False)
       // {
       //     return (False);
       // }

        if (STS_IsReady() == True)
        {
            #if (HAMARO_WIN_DEBUG & STS_ENABLE_SENSE_CHANNEL_TRACE)
            STSDBG_WR_STR("^ STS IS READY ^", True);
            #endif /* HAMARO_WIN_DEBUG */
            break;
        }

        if (read_count == 10000)
        {
            #if (HAMARO_WIN_DEBUG & STS_ENABLE_SENSE_CHANNEL_TRACE)
            STSDBG_WR_STR("v Count timeout v", True);
            #endif /* HAMARO_WIN_DEBUG */
            break;
        }
      //  for (delay = 0; delay < 2000; delay++)
        //for (delay = 0; delay < 200; delay++)
       //     ;
        read_count++;
    } while (forever);

    return (True);
}

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


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

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

/*****************************************************************************/
/* STS_LogPowerSpectrum() - this is DEBUG only */
/*****************************************************************************/
void 
STS_LogPowerSpectrum(unsigned char format)
{
    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;
    }

    loop = *p_filled_buffer_length-1;

    if (format == 1)
    {
        for (; loop >= 0; loop--)
        {
            STSDBG_WR_UNSIGNED_LN("[Absolute freq hz] = ", (int)p_freq_reading[loop]);
            STSDBG_WR_UNSIGNED_LN("[Power measurement] = ", (int)p_power_reading[loop]);
        }
    }
    else if (format == 2)
    {
        for (; loop >= 0; loop--)
        {
            STSDBG_WR_UNSIGNED_LN("freq1(hz) = ", (int)p_freq_reading[loop]);
            STSDBG_WR_UNSIGNED_LN("Power1 = ", (int)p_power_reading[loop]);
        }
    }
    else 
    {
        for (; loop >= 0; loop--)
        {
            STSDBG_WR_UNSIGNED_LN("freq2(hz) = ", (int)p_freq_reading[loop]);
            STSDBG_WR_UNSIGNED_LN("Power2 = ", (int)p_power_reading[loop]);
        }
    }
 }

/*****************************************************************************/
/* 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_UNSIGNED_LN("[AAGC] = ",s_power_spectrum_data.agcacc);        
 }


/*****************************************************************************/
/* STS_GetFirstFreq() */
/*****************************************************************************/
BOOL
STS_GetFirstFreq(unsigned long* p_first_freq)
{
    unsigned long*  p_freq_reading = 0;
    unsigned short* p_filled_buffer_length = 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;
    }
    else
    {
        p_freq_reading = &s_power_spectrum_data.sub_abs_freq[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_sub_buffer_len;
    }

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

/*****************************************************************************/
/* STS_GetIndexFromFreq() */
/*****************************************************************************/
unsigned short
STS_GetIndexFromFreq(unsigned long freq)
{  
    short index;
    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;
    }
    else
    {
        p_freq_reading = &s_power_spectrum_data.sub_abs_freq[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_sub_buffer_len;
    }

    index = *p_filled_buffer_length-1;

	for (; index >= 0; index--)
	{
		if (freq <= p_freq_reading[index])
		{
			break;
		}
	}
    if (index < 0)
    {
        index = 0;
    }

    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* p_filled_buffer_length = 0;

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

    s_iter = *p_filled_buffer_length-1;

    if (start_index != 0xFFFF) /* caller specified */
    {
        if (start_index <= *p_filled_buffer_length)
        {
            s_iter = start_index;
            *p_filled_buffer_length = s_iter+1;
        }
        else
        {
            s_iter = *p_filled_buffer_length-1;
        }
    }
    return (True);
}

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

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

    if (s_iter > (*p_filled_buffer_length-1))
    {
        STSDBG_WR_STR ("[STS_MeasurementIterPrev] OVERFLOW", True);
        return (False);
    }

    if (*p_filled_buffer_length && ((*p_filled_buffer_length-1) >= step))
    {
        if (s_iter >= 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* p_filled_buffer_length = 0;

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

    if (s_iter > (*p_filled_buffer_length-1))
    {
        STSDBG_WR_STR ("[STS_MeasurementIterPrev] OVERFLOW", True);
        return (False);
    }

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

/*****************************************************************************/
/* STS_GetLeftFreqMeasurement()  */
/*****************************************************************************/
unsigned long 
STS_GetLeftFreqMeasurement(unsigned short step)
{
    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 (s_iter >= step)
    {
        return p_freq_reading[s_iter-step];
    }
    return 0;
}

/*****************************************************************************/
/* STS_GetMiddleFreqMeasurement() - a value of 0 means no measurement available */
/*****************************************************************************/
unsigned long 
STS_GetMiddleFreqMeasurement()
{
    unsigned long* p_freq_reading = 0;
    unsigned short* p_filled_buffer_length = 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;
    }
    else
    {
        p_freq_reading = &s_power_spectrum_data.sub_abs_freq[0]; 
        p_filled_buffer_length = &s_power_spectrum_data.filled_sub_buffer_len;