hamaro_pwrscan.c

QPSK Tuner details, for conexant chipset.

    {
#if STS_ENABLE_VERBOSE_LOG
        STSDBG_WR_INT_LN("number_freq_cnt derived = ", constraint1);
#endif /* STS_ENABLE_VERBOSE_LOG */
        return ((unsigned short)constraint1);
    }
    else
    {
#if STS_ENABLE_VERBOSE_LOG
        STSDBG_WR_INT_LN("number_freq_cnt derived = ", constraint2);
#endif /* STS_ENABLE_VERBOSE_LOG */
        return ((unsigned short)constraint2);
    }
}

/*****************************************************************************/
/* PWRSCAN_GetSegmentMaxPowerReading() */
/*****************************************************************************/
static unsigned short s_max_raw_power_reading;
static unsigned short s_sub_max_raw_power_reading;
static unsigned short
PWRSCAN_GetSegmentMaxPowerReading()
{
    if (STS_GetUseMainBuffer() == True)
    {
        return s_max_raw_power_reading;
    }
    else
    {
        return s_sub_max_raw_power_reading;
    }
}

/*****************************************************************************/
/* PWRSCAN_GetMaxRawPowerReading() */
/*****************************************************************************/
unsigned short
PWRSCAN_GetMaxRawPowerReading()
{
    if (STS_GetUseMainBuffer() == True)
    {
        return PWRSCAN_GetScaledMaxPowerReading();
    }
    else
    {
        return s_sub_max_raw_power_reading;
    }
}

/*****************************************************************************/
/* PWRSCAN_SetMaxRawPowerReading() */
/*****************************************************************************/
static void
PWRSCAN_SetMaxRawPowerReading(unsigned short max_power)
{
    if (STS_GetUseMainBuffer() == True)
    {
        s_max_raw_power_reading = max_power;
    }
    else
    {
        s_sub_max_raw_power_reading = max_power;
    }
}

/*****************************************************************************/
/* PWRSCAN_ProgramPLLMult() */
/*****************************************************************************/
static BOOL
PWRSCAN_ProgramPLLMult(unsigned long pll_mult)
{
    if (HAMARO_RegisterWrite(hamaro_nim_list.nim[0], CX2430X_PLLMULT, pll_mult, HAMARO_DEMOD_I2C_IO) == False)
    {
        return (False);
    }    

    hamaro_nim_list.nim[0]->ucPLLMult_shadow = (unsigned char)pll_mult;

    STSDBG_WR_UNSIGNED_LN("PLL Mult = ", pll_mult);
    STSDBG_WR_UNSIGNED_LN("fsample = ", fsample);

    return(True);
}

/*****************************************************************************/
/* PWRSCAN_ErrorClear() */
/*****************************************************************************/
static BOOL
PWRSCAN_ErrorClear()
{
    if (STS_WRITE(STS_ERR_CLR, 1) == False)
    {
        return (False);
    }
    return (True);
}

/*****************************************************************************/
/* PWRSCAN_CheckErrors() */
/*****************************************************************************/
static BOOL 
PWRSCAN_CheckErrors()
{
    unsigned short  read_value;

    if (STS_READ(STS_FSM_ERR, &read_value) == False)
    {        
        return (False);
    }

    if (read_value == 1)
    {
        STSDBG_WR_INT_LN("<<< Read FSM_ERR >>> = ", read_value);
        PWRSCAN_ErrorClear();
        return (False);
    }

    if (STS_READ(STS_FIFO_ERR, &read_value) == False)
    {
        return (False);
    }

    if (read_value == 1)
    {
        STSDBG_WR_INT_LN("<<< Read FIFO_ERR >>> = ", read_value);
        PWRSCAN_ErrorClear();
        return (False);
    }

    return (True);
}

/*****************************************************************************/
/* PWRSCAN_SetTunerFrequency() */
/*****************************************************************************/
static BOOL
PWRSCAN_SetTunerFrequency(unsigned long frequency, BOOL* p_pll_lock, unsigned long* p_actual_tuner_frequency)
{   
    if (HAMARO_SetTunerFrequency(hamaro_nim_list.nim[0], frequency) == False)  
    {
        return(False);
    }

//#if STS_ENABLE_VERBOSE_LOG
    STSDBG_WR_INT("Set tuner frequency = ", frequency);
//#endif /* STS_ENABLE_VERBOSE_LOG */

    if (p_pll_lock != 0)
    {
        if (HAMARO_TUNER_GetPLLLockStatus(hamaro_nim_list.nim[0], p_pll_lock) == False)
        {
            return (False);
        }

#if STS_ENABLE_VERBOSE_LOG
        STSDBG_WR_INT(" | PLL lock = ", *p_pll_lock);
#endif /* STS_ENABLE_VERBOSE_LOG */
    }

    if (p_actual_tuner_frequency != 0)
    {
        /* get the tuner pll settings, calculate the deviation */
        if (HAMARO_TUNER_GetPLLFrequency(hamaro_nim_list.nim[0], p_actual_tuner_frequency) == False)  
        {
            return(False);
        }    
#if STS_ENABLE_VERBOSE_LOG
    STSDBG_WR_INT_LN(" | Actual tuner frequency = ", *p_actual_tuner_frequency);
#endif /* STS_ENABLE_VERBOSE_LOG */
    }

    return (True);
}

/*****************************************************************************/
/* PWRSCAN_OpenBandwidth() */
/*****************************************************************************/
static BOOL
PWRSCAN_OpenBandwidth(unsigned long roll_off, unsigned long symb_rate_ksps, long lnb_offset)
{
    HAMARO_BCDNO    bcd;
    long		    lnboffset;
    unsigned long   bandwidth;
    unsigned long   bwAdjFactor;
    long		    sigmadelta;   

	HAMARO_BCD_set (&bcd, roll_off);    /* roll-off x 1000 */		
	HAMARO_BCD_mult(&bcd, symb_rate_ksps);  /* max symbol rate in Ksps */  
	HAMARO_BCD_div (&bcd, 1000UL);   
    lnboffset = lnb_offset;               /* LNB offset */
	bwAdjFactor = HAMARO_BCD_out(&bcd);		
	bandwidth = (unsigned long)labs(lnboffset) + bwAdjFactor;	

	HAMARO_SetTunerBW(hamaro_nim_list.nim[0], bandwidth, &sigmadelta);

    return (True);
}

/*****************************************************************************/
/* PWRSCAN_Enable() : True = Enable; False = Disable */
/*****************************************************************************/
BOOL
PWRSCAN_Enable(BOOL enable) 
{
    unsigned short value = ((enable == True) ? 1 : 0);
    
    if (value == 1)
    {
        STS_UpdateState(HAMARO_STS_MODULE_ON);
    }
    else
    {
        STS_UpdateState(HAMARO_STS_MODULE_OFF);
    }

    PWRSCAN_ErrorClear();

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

    if (STS_READ(STS_ENABLE, &value) == False)
    {
        return (False);
    }
    else
    {
        STSDBG_WR_UNSIGNED_LN("STS_ENABLE = ", value);
    }

    PWRSCAN_ErrorClear();
    PWRSCAN_CheckErrors();
    return (True);
}


/*****************************************************************************/
/* PWRSCAN_ReadyClear() */
/*****************************************************************************/
static BOOL
PWRSCAN_ReadyClear()
{
    if (STS_WRITE(STS_READY_CLR, 1) == False)
    {
        return (False);
    }
    return (True);
}

/*****************************************************************************/
/* PWRSCAN_IsReady() */
/*****************************************************************************/
static BOOL
PWRSCAN_IsReady()
{
    unsigned short  read_value;

    if (STS_READ(STS_READY, &read_value) == False)
    {
        return (False);
    }
    if (read_value == 1)
    {
        return (True);
    }
    return (False);
}

/*****************************************************************************/
/* PWRSCAN_SetObservationWindow() */
/*****************************************************************************/
static BOOL
PWRSCAN_SetObservationWindow (unsigned short sts_len_sel)
{
    if (STS_WRITE(STS_LEN_SEL, sts_len_sel) == False)
    {
        return (False);
    }
    return (True);
}

/*****************************************************************************/
static BOOL
PWRSCAN_WriteCenterFreq(signed long frequency_offset)
{
    unsigned short  read_value;
    int    neg = 1;
    HAMARO_BCDNO  bcd;
    signed short    center_freq_signed;

    if (frequency_offset < 0L)
    {
        neg = -1;
        frequency_offset = (frequency_offset * -1L);
    }

    HAMARO_BCD_set(&bcd,(unsigned long)frequency_offset);
    HAMARO_BCD_mult(&bcd,(0x01<<16));
    HAMARO_BCD_div(&bcd,fsample);

    center_freq_signed = (short)HAMARO_BCD_out(&bcd);
    center_freq_signed = (short)(center_freq_signed * neg);

#if STS_ENABLE_VERBOSE_LOG
    STSDBG_WR_INT("\nCalculated central_frequency = ", center_freq_signed);
#endif /* STS_ENABLE_VERBOSE_LOG */

    if (STS_WRITE(STS_CENTER_FREQ, center_freq_signed) == False)
    {
        return (False);
    }

    if (STS_READ(STS_CENTER_FREQ, &read_value) == False)
    {
        return (False);
    }

#if STS_ENABLE_VERBOSE_LOG
    STSDBG_WR_INT_LN("Read STS_CENTER_FREQ = ", (signed short)read_value);
#endif /* STS_ENABLE_VERBOSE_LOG */
    return (True);
}

/*****************************************************************************/
/* PWRSCAN_GetSymbolRate() */
/*****************************************************************************/
/*static*/ BOOL 
PWRSCAN_GetSymbolRate(unsigned long* p_symbolrate)
{
    unsigned long  temp_symbolrate;

    /* read the symbolrate teh demod is set to */
    if (HAMARO_RegisterRead(hamaro_nim_list.nim[0], CX2430X_SYSSYMBOLRATE, p_symbolrate, HAMARO_DEMOD_I2C_IO) == False)  return(False);

    /* compute the symbolrate to be returned to the caller */
    temp_symbolrate = (unsigned long)HAMARO_DRIVER_symbolrate_out(*p_symbolrate, fsample);
    *p_symbolrate = temp_symbolrate;

    return (True);
}  /* PWRSCAN_GetSymbolRate() */

/*****************************************************************************/
/* PWRSCAN_GetFreqStep() */
/*****************************************************************************/
static BOOL
PWRSCAN_GetFreqStep(signed long frequency_step, signed short* p_value, unsigned long mfclk)
{
    int    neg = 1;
    HAMARO_BCDNO  bcd;

    if (frequency_step < 0L)
    {
        neg = -1;
        frequency_step = (frequency_step * -1L);
    }

    HAMARO_BCD_set(&bcd,(unsigned long)frequency_step);
    HAMARO_BCD_mult(&bcd,(0x01<<12));
    HAMARO_BCD_div(&bcd,mfclk); 

    *p_value = (short)HAMARO_BCD_out(&bcd);
    *p_value = (short)(*p_value * neg);
    *p_value = (signed short)HAMARO_DRIVER_convert_twos_saturate(*p_value, 16);

#if STS_ENABLE_VERBOSE_LOG
#if HAMARO_WIN_DEBUG
    // WINDBG_FileWriteNewLine();
#endif /* HAMARO_WIN_DEBUG */
    STSDBG_WR_INT("Calculated STS frequency = ", *p_value);
#endif /* STS_ENABLE_VERBOSE_LOG */
    return (True);
}

/*****************************************************************************/
/* PWRSCAN_WriteFreqStep() */
/*****************************************************************************/
static BOOL
PWRSCAN_WriteFreqStep(unsigned char addr, int frequency_step, unsigned long symbol_rate_hz)
{
    signed short freq_step;

#if SKYSCAN_IQ_INVERSION == NO
    frequency_step = -frequency_step;
#endif     

    if (PWRSCAN_GetFreqStep(frequency_step, &freq_step, symbol_rate_hz) == False)
    {
        STSDBG_WR_INT_LN("PWRSCAN_GetFreqStep failed for = ", frequency_step);
        return (False);
    }

    if (STS_WRITE_OFFSET(STS_FREQ_MEM0, addr, freq_step) == False)