phantom_api.c

来自「QPSK Tuner details, for conexant chipset」· C语言 代码 · 共 1,923 行 · 第 1/5 页

 * PHANTOM_GetSpectralInversion()
 * Function to read the demod's spectral inversion setting  
 *******************************************************************************************************/
BOOL      
PHANTOM_GetSpectralInversion(PHANTOM_NIM      *p_nim,      /* pointer to nim */
                             PHANTOM_SPEC_INV  *p_specinv)  /* returned spectral inv. settings */
{
    unsigned long reg_value;

    if (p_specinv == 0)
    {
        return (False);
    }

    if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_9C_SPECINV, &reg_value, PHANTOM_USE_DEMOD_HANDLE) == False)
    {
        return (False);
    }
    
    *p_specinv = (PHANTOM_SPEC_INV)reg_value;

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



/*******************************************************************************************************
 * PHANTOM_GetLockState() 
 * function to test and report state of demod's acq. engine 
 *******************************************************************************************************/
BOOL      
PHANTOM_GetLockState(PHANTOM_NIM        *p_nim,      /* pointer to nim */
                     PHANTOM_ACQ_STATE  *p_acqstate) /* returned state */
{
    unsigned long  trackingstate;

    /* test PHANTOM_NIM for validity */
	PHANTOM_DBG_VALIDATE_NIM(p_nim);

    /* allow a reset of the last-known prev-state */
    if (p_acqstate == 0)
    {
        p_nim->prev_acqstate = PHANTOM_ACQ_OFF;
        return(False);
    }

    /* Read Page0 location (TBD) for acquisition state into trackingstate */
    trackingstate = p_nim->track_state;

    /* force acq state from undefined to known state */
    if (p_nim->prev_acqstate == PHANTOM_ACQ_UNDEF)  
    {
        p_nim->prev_acqstate = PHANTOM_ACQ_OFF;
    }

    /* if locked, save good news, else perform some more */
    if (trackingstate == PHANTOM_TRACK_LOCKED)
    {
        *p_acqstate = PHANTOM_ACQ_LOCKED_AND_TRACKING;
    }    
    else
    {
        /* state is not locked, see what the demod WAS doing */
        if (p_nim->prev_acqstate == PHANTOM_ACQ_OFF || p_nim->prev_acqstate == PHANTOM_ACQ_SEARCHING)  
        {
            *p_acqstate = PHANTOM_ACQ_SEARCHING;
        }
        else
        {
            if (p_nim->prev_acqstate == PHANTOM_ACQ_LOCKED_AND_TRACKING)  
            {
                *p_acqstate = PHANTOM_ACQ_FADE;
            }
            else
            {
                if (p_nim->prev_acqstate == PHANTOM_ACQ_FADE)  
                {
                    *p_acqstate = PHANTOM_ACQ_FADE;
                }
            }
        }
    }

    /* save the last-known state */
    p_nim->prev_acqstate = *p_acqstate;

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



/*******************************************************************************************************
 * PHANTOM_SetInterruptOptions()
 * function to set interrupt options  
 *******************************************************************************************************/
BOOL       
PHANTOM_SetInterruptOptions(PHANTOM_NIM          *p_nim,     /* pointer to nim */
                            PHANTOM_INTR_OPTIONS interopts)  /* interrupt settings */
{
	BOOL return_val = False;

	/* Validate nim */
	PHANTOM_DBG_VALIDATE_NIM(p_nim);

	/* clear the pending demod interrupt */
	return_val = PHANTOM_LLF_InterruptControl (p_nim, 0, (unsigned char)interopts);

	return (return_val);
}  /* PHANTOM_SetInterruptOptions() */


/*******************************************************************************************************
 * PHANTOM_GetPendingInterrupts()  (See also PHANTOM_SetInterruptOptions() ) 
 * function to read demod's pending interrupts
 *******************************************************************************************************/
BOOL       
PHANTOM_GetPendingInterrupts(PHANTOM_NIM          *p_nim,      /* pointer to nim */
                             PHANTOM_INTR_OPTIONS *p_interopts)/* pending interrupts (bit mask of) */
{
	unsigned long  reg_value = 0; 

	BOOL   rtn = False;

	/* validate p_nim and mpeg storage */
	PHANTOM_DBG_VALIDATE_NIM(p_nim);

	if (p_interopts == 0)  
	{
		PHANTOM_DBG_SET_ERROR(PHANTOM_BADPTR);
	}
	else
	{   /* read interrupt options from demod */
		rtn = PHANTOM_RegisterRead(p_nim, PHANTOM_P0_BB_INTR_PENDING, &reg_value, PHANTOM_USE_DEMOD_HANDLE);
		*p_interopts = (PHANTOM_INTR_OPTIONS)reg_value;
	}

	return(rtn);
}  /* PHANTOM_GetPendingInterrupts() */


/*******************************************************************************************************
 * PHANTOM_ClearPendingInterrupts() 
 * function to clear (write zero to) pending intr register 
 *******************************************************************************************************/
BOOL      
PHANTOM_ClearPendingInterrupts(PHANTOM_NIM          *p_nim,   /* pointer to nim */
                               PHANTOM_INTR_OPTIONS interopts)
{
	BOOL return_val = False;

	/* Validate nim */
	PHANTOM_DBG_VALIDATE_NIM(p_nim);

	/* clear the pending demod interrupt */
	return_val = PHANTOM_LLF_InterruptControl (p_nim, 1, (unsigned char)interopts);

	return (return_val);
}  /* PHANTOM_ClearPendingInterrupts() */


/*******************************************************************************************************
 * PHANTOM_GetLockIndicators() 
 * function to read all demod lock indicators 
 *******************************************************************************************************/
BOOL      
PHANTOM_GetLockIndicators(PHANTOM_NIM       *p_nim,       /* pointer to nim */
                      PHANTOM_LOCKIND   *p_lockinds)  /* returned lock indicator struct */
{
	unsigned long  sync_status;

	/* validate nim */
	PHANTOM_DBG_VALIDATE_NIM(p_nim);

	if (p_lockinds == 0)  
	{
		PHANTOM_DBG_SET_ERROR(PHANTOM_BADPTR);
	}
	else
	{
		/* pre-set lock indicators to False */
		p_lockinds->pll          = False;
		p_lockinds->demod_sync   = False;
		p_lockinds->ldpc         = False;
		p_lockinds->viterbi      = False;
        p_lockinds->bch          = False;
		p_lockinds->reed_solomon = False;
		p_lockinds->lp           = False;

		/* read the entire register, pull-out pertinent data */
		if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_9D_LOCK_STATUS, &sync_status, PHANTOM_USE_DEMOD_HANDLE) == True)  
		{
			/* mask each lock ind. from the register */
			if (((unsigned char)sync_status & phantom_register_map[PHANTOM_P0_9D_PLL_LOCK].p_hw_mask[0]) != 0)    
			{
				p_lockinds->pll = True;
			}
			if (((unsigned char)sync_status & phantom_register_map[PHANTOM_P0_9D_DEMOD_SYNC_LOCK].p_hw_mask[0]) != 0)       
			{
				p_lockinds->demod_sync = True;
			}
			if (((unsigned char)sync_status & phantom_register_map[PHANTOM_P0_9D_LDPC_LOCK].p_hw_mask[0]) != 0)       
			{
				p_lockinds->ldpc = True;
			}
			if (((unsigned char)sync_status & phantom_register_map[PHANTOM_P0_9D_VITERBI_LOCK].p_hw_mask[0]) != 0)      
			{
				p_lockinds->viterbi = True;
			}
			if (((unsigned char)sync_status & phantom_register_map[PHANTOM_P0_9D_BCH_LOCK].p_hw_mask[0]) != 0)  
			{
				p_lockinds->bch = True;
			}
			if (((unsigned char)sync_status & phantom_register_map[PHANTOM_P0_9D_RS_LOCK].p_hw_mask[0]) != 0)      
			{
				p_lockinds->reed_solomon = True;
			}
			if (((unsigned char)sync_status & phantom_register_map[PHANTOM_P0_9D_LP_LOCK].p_hw_mask[0]) != 0)      
			{
				p_lockinds->lp = True;
			}

            if (p_nim->rx_operation_mode >=4 && p_nim->rx_operation_mode <= 17) // NBC
            {
                if (p_lockinds->bch == True)
                {
                    p_nim->track_state = PHANTOM_TRACK_LOCKED;
                }
                else
                {
                    p_nim->track_state = PHANTOM_TRACK_INIT;
                }
            }
            if (p_nim->rx_operation_mode >=40 && p_nim->rx_operation_mode <= 50) // legacy
            {
                if (p_lockinds->reed_solomon == True)
                {
                    p_nim->track_state = PHANTOM_TRACK_LOCKED;
                }
                else
                {
                    p_nim->track_state = PHANTOM_TRACK_INIT;
                }
            }
			return(True);
		}
	}
    return(True);
}  /* PHANTOM_GetLockIndicators() */



/*******************************************************************************************************
 * PHANTOM_GetChannelEsNo() 
 * Function to get channel esno in dB (Scaled up by 10). Caller must divide the returned value by 10.
 *******************************************************************************************************/
BOOL     
PHANTOM_GetChannelEsNo(PHANTOM_NIM *p_nim, unsigned short *p_esno) 
{
    unsigned long reg_value;

	/* Read the EsNo */
    if (p_esno == 0)
    {
        return (False);
    }

    /* MSB */
    if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_A3_ESNO_ESTIMATION_MSB, &reg_value, PHANTOM_USE_DEMOD_HANDLE) == False)
    {
        return (False);
    }

    *p_esno = (unsigned short)(reg_value << 8UL);

    /* LSB */
    if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_D5_ESNO_ESTIMATION_LSB, &reg_value, PHANTOM_USE_DEMOD_HANDLE) == False)
    {
        return (False);
    }

    *p_esno |= (unsigned short)reg_value;

    if (*p_esno > 300)
    {
        *p_esno = 300;
    }

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



/*******************************************************************************************************
 * PHANTOM_GetCTL() 
 * function to read demod's CTL register 
 * The return value is in kHz.
 *******************************************************************************************************/
BOOL  
PHANTOM_GetCTL(PHANTOM_NIM   *p_nim,/* pointer to nim */
           long  *p_ctl)/* returned ctl value to caller */
{
    unsigned long reg_value;

    /* validate nim */
    PHANTOM_DBG_VALIDATE_NIM(p_nim);

	if (p_ctl == 0)
	{
		PHANTOM_DBG_SET_ERROR(PHANTOM_BADPTR);
		return (False);
	}

    if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_9F_FREQ_OFFSET, &reg_value, PHANTOM_USE_DEMOD_HANDLE) == False)
    {
        return (False);
    }

    /* Convert to 2's complement number */
    *p_ctl = (long)PHANTOM_DRIVER_ConvertToTwos(reg_value, 16);

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


/*******************************************************************************************************
 * PHANTOM_GetAGCAcc() 
 * function to read the demod AGC accumulator value 
 *******************************************************************************************************/
BOOL    
PHANTOM_GetAGCAcc(PHANTOM_NIM     *p_nim,             /* pointer to nim */
                  PHANTOM_AGCACC  *p_agcacc,          /* AGC accumulator value returned to caller */
                  signed char     *p_estimated_power, /* estimated input power level */
			      unsigned char   *p_saturated)       /* saturated */
{
    unsigned long reg_value;

	/* validate nim */
	PHANTOM_DBG_VALIDATE_NIM(p_nim);

	if (p_agcacc != 0)
	{
        *p_agcacc = 0;
	}

    if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_9D_ANALOG_AGC_MSBITS, &reg_value, PHANTOM_USE_DEMOD_HANDLE) == False) /* 9:8 */
    {
        return (False);
    }

    *p_agcacc = reg_value << 8;

    if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_9E_ANALOG_AGC_LSBITS, &reg_value, PHANTOM_USE_DEMOD_HANDLE) == False) /* 7:0 */
    {
        return (False);
    }

    *p_agcacc |= (reg_value & 0xFF);

	if ((*p_agcacc == 1023UL) || (*p_agcacc == 0UL)) /* check for 10-bit limits */
	{
		*p_saturated = 1;    /* saturated */  
	}
	else
	{
		*p_saturated = 0;
	}
    
    if (PHANTOM_RegisterRead(p_nim, PHANTOM_P0_DA_ESTIMATED_INPUT_POWER, &reg_value, PHANTOM_USE_DEMOD_HANDLE) == False) /* 7:0 */
    {
        return (False);
    }

    *p_estimated_power = (signed char)(reg_value & 0xFF); 

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



/*******************************************************************************************************
 * PHANTOM_GetBTL() 
 * function to read the BTL register from the demod 
 * The return value is in Hz
 *******************************************************************************************************/
BOOL