d0299.c

st7710的tuner标准驱动

    /* finally (as nor more errors to check for, allocate handle */
    Instance->TopLevelHandle = OpenParams->TopLevelHandle;
    
    /* in loopthriugh mode the second demod which is connected by loopthrough of first cannot send disecq-st 
       command because of a DC block in the loop-through path. Presently it depends upon toplevelhandle but when tone detection 
       LLA of SatCR will be written "DISECQ_ST_ENABLE" will be initalized automatically depending upon the tone sent*/
    #ifdef STTUNER_DRV_SAT_SCR
		#ifdef STTUNER_DRV_SAT_SCR_LOOPTHROUGH
		    if(OpenParams->TopLevelHandle == 0)
		    Instance->DISECQ_ST_ENABLE = TRUE;
		    if(OpenParams->TopLevelHandle == 1)
		    Instance->DISECQ_ST_ENABLE = FALSE;
	    #endif
	#endif
    
	*Handle = (U32)Instance;

#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
    STTBX_Print(("%s opened ok\n", identity));
#endif

    SEM_UNLOCK(Lock_InitTermOpenClose);
    
    /* GNBvd17801-> Error Handling for any error returned during I2C operation inside the driver */
    Error |= Instance->DeviceMap.Error;
    Instance->DeviceMap.Error = ST_NO_ERROR;
    #endif
/**************************************************************************
*****************************************************************************/    
#ifdef STTUNER_MINIDRIVER
    U8 Data;
        /* now safe to lock semaphore */
    SEM_LOCK(Lock_InitTermOpenClose);
   
    /* write all demod register with default values */
    Error = STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, 0x00,0,0,DEFAULT_Register_0299, 69, FALSE);
    
    if (Error != ST_NO_ERROR)
    {
        SEM_UNLOCK(Lock_InitTermOpenClose);
	return(Error);
    }
    Capability->SymbolMin       = STV0299_SYMBOL_RATE_MIN; /*   1 MegaSymbols/sec */
    Capability->SymbolMax       = STV0299_SYMBOL_RATE_MAX; /*  50 MegaSymbols/sec */

    /* TS output mode */
    switch (DEMODInstance->TSOutputMode)
    {
        case STTUNER_TS_MODE_SERIAL:
             Data = 1;
             STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_FECM, F0299_OUTPUTTYPE, F0299_OUTPUTTYPE_L, &Data, 1, FALSE);
             break;

        default:
        case STTUNER_TS_MODE_PARALLEL:
        case STTUNER_TS_MODE_DEFAULT:
             Data = 0;
             STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_FECM, F0299_OUTPUTTYPE, F0299_OUTPUTTYPE_L, &Data, 1, FALSE);
             break;
    }
    /* Set FEC mode */
    switch (DEMODInstance->FECMode)
    {
        case STTUNER_FEC_MODE_DIRECTV:
        Data = 4;
        STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_FECM, F0299_FECMODE, F0299_FECMODE_L, &Data, 1, FALSE);
        Data = 1;
        STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_IOCFG, F0299_NYQUISTFILTER, F0299_NYQUISTFILTER_L, &Data, 1, FALSE);
        Data = 0;
        STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS, F0299_DESCRAMBLER, F0299_DESCRAMBLER_L, &Data, 1, FALSE);
        break;

        default:
        case STTUNER_FEC_MODE_DEFAULT:
        case STTUNER_FEC_MODE_DVB:
        Data = 0;
        STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_FECM, F0299_FECMODE, F0299_FECMODE_L, &Data, 1, FALSE);
        break;
    }

    /* Only set serial configuration if serial mode output */
    if (DEMODInstance->TSOutputMode == STTUNER_TS_MODE_SERIAL)
    {
        /* Set serial clock source */
        switch(DEMODInstance->SerialClockSource)
        {
            case STTUNER_SCLK_VCODIV6:
            Data = 1;
            STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_MCR, F0299_SERCLK, F0299_SERCLK_L, &Data, 1, FALSE);
            break;

            default:
            case STTUNER_SCLK_DEFAULT:
            case STTUNER_SCLK_MASTER:
            Data = 0;
            STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_MCR, F0299_SERCLK, F0299_SERCLK_L, &Data, 1, FALSE);
            break;
        }

        /* Set serial data mode */
        
        if ( (DEMODInstance->SerialDataMode & STTUNER_SDAT_VALID_RISING) != 0)    /* Rising edge according to 299 data sheet*/
        {
            Data = 0;
            STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS,F0299_OUTPUTCLOCKPOLARITY,F0299_OUTPUTCLOCKPOLARITY_L, &Data, 1, FALSE);
            
        }
        else
        {
            Data = 1;
            STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS,F0299_OUTPUTCLOCKPOLARITY,F0299_OUTPUTCLOCKPOLARITY_L, &Data, 1, FALSE);
            
        }

        if ((DEMODInstance->SerialDataMode & STTUNER_SDAT_PARITY_ENABLE) != 0)     /* Parity enable according to 299 data sheet */
        {
            Data = 0;
            STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS, F0299_OUTPUTCLOCKCONFIG, F0299_OUTPUTCLOCKCONFIG_L, &Data, 1, FALSE);
            
        }
        else
        {
            Data = 1;
            STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS, F0299_OUTPUTCLOCKCONFIG, F0299_OUTPUTCLOCKCONFIG_L, &Data, 1, FALSE);
            
        }

    } /* if(OpenParams->TSOutputMode) */

   /* This will control sync byte, 0x47 or 0xb8 after every 8th packet*/
   #ifdef STTUNER_BLOCK_SYNC_MODE_SELECT
    switch(DEMODInstance->BlockSyncMode)
    { case STTUNER_SYNC_NORMAL:
    	   Data = 0;
    	   STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS, F0299_BLOCKSYNCHRO, F0299_BLOCKSYNCHRO_L, &Data,1, FALSE);
           
           break;
      case STTUNER_SYNC_DEFAULT:
      case STTUNER_SYNC_FORCED:
           Data = 1;
           STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS, F0299_BLOCKSYNCHRO, F0299_BLOCKSYNCHRO_L, &Data, 1, FALSE);
           break;
       default:
           Data = 1;
           STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_RS, F0299_BLOCKSYNCHRO,F0299_BLOCKSYNCHRO_L, &Data, 1, FALSE);
            break;
     }
     #endif
     
     Data = 1;
     STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R0299_AGC1R, F0299_IAGC,F0299_IAGC_L, &Data,1, FALSE);
   
   DEMODInstance->TopLevelHandle = OpenParams->TopLevelHandle;

   #ifdef STTUNER_DRV_SAT_SCR
		#ifdef STTUNER_DRV_SAT_SCR_LOOPTHROUGH
		    if(OpenParams->TopLevelHandle == 0)
		    DEMODInstance->DISECQ_ST_ENABLE = TRUE;
		    if(OpenParams->TopLevelHandle == 1)
		    DEMODInstance->DISECQ_ST_ENABLE = FALSE;
	    #endif
	#endif
    
	*Handle = (U32)DEMODInstance;

#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
    STTBX_Print(("%s opened ok\n", identity));
#endif

    SEM_UNLOCK(Lock_InitTermOpenClose);
    
    
    #endif
    
    return(Error);
}   

#ifdef STTUNER_MINIDRIVER
ST_ErrorCode_t demod_d0299_Close(DEMOD_Handle_t Handle, DEMOD_CloseParams_t *CloseParams)
{
	DEMODInstance->TopLevelHandle = STTUNER_MAX_HANDLES;
	return(ST_NO_ERROR);
}
#endif

#ifndef STTUNER_MINIDRIVER
/* ----------------------------------------------------------------------------
Name: demod_d0299_Close()

Description:
    
Parameters:
    
Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0299_Close(DEMOD_Handle_t Handle, DEMOD_CloseParams_t *CloseParams)
{
#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
   const char *identity = "STTUNER d0299.c demod_d0299_Close()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    D0299_InstanceData_t     *Instance;

    /* private driver instance data */
    Instance = D0299_GetInstFromHandle(Handle);

    if(Installed == FALSE)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
        STTBX_Print(("%s fail driver not installed\n", identity));
#endif
        return(STTUNER_ERROR_INITSTATE);
    }

    SEM_LOCK(Lock_InitTermOpenClose);

    /* ---------- check that at least one init has taken place ---------- */
    if(InstanceChainTop == NULL)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
        STTBX_Print(("%s fail nothing initalized\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(STTUNER_ERROR_INITSTATE);
    }

    if(Instance->TopLevelHandle == STTUNER_MAX_HANDLES)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
        STTBX_Print(("%s fail driver instance not open\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(ST_ERROR_OPEN_HANDLE);
    }

    /* put chip to sleep */
/*
    Error = STTUNER_IOREG_SetField(&Instance->DeviceMap, Instance->IOHandle,  F0299_STDBY, 1);
    if (Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
        STTBX_Print(("%s fail set standby\n", identity));
#endif
    } */   /* continue */

    Instance->TopLevelHandle = STTUNER_MAX_HANDLES;

#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
    STTBX_Print(("%s closed\n", identity));
#endif

    SEM_UNLOCK(Lock_InitTermOpenClose);
    return(Error);
}   



/* ----------------------------------------------------------------------------
Name: demod_d0299_IsAnalogCarrier()

Description:
    This routine checks for an analog carrier on the current frequency
    by setting the symbol rate to 5M (never a digital signal).

Parameters:
    IsAnalog,   pointer to area to store result:
                TRUE - is analog
                FALSE - is not analog

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0299_IsAnalogCarrier(DEMOD_Handle_t Handle, BOOL *IsAnalog)        
{
#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
   const char *identity = "STTUNER d0299.c demod_d0299_IsAnalogCarrier()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    U8 loop;
    U16 Agc2;
    U8 AGCIntegrator[2];
    D0299_InstanceData_t *Instance;

    /* private driver instance data */
    Instance = D0299_GetInstFromHandle(Handle);

     Agc2 = 0;
    *IsAnalog = FALSE;  /* Assume no analog carrier */

    /* Set the symbol rate to analog carrier rate */
    Reg0299_RegSetSymbolRate(& Instance->DeviceMap, Instance->IOHandle, ANALOG_CARRIER_DETECT_SYMBOL_RATE);

    /* Take four AGC2 samples */
    for (loop = 0; loop < 4; loop++)
    {
        /* Read AGC2I1 and AGC2I2 registers */
        STTUNER_IOREG_GetContigousRegisters(&Instance->DeviceMap, Instance->IOHandle, R0299_AGC2I1, 2,AGCIntegrator);

        Agc2 += (AGCIntegrator[0]<<8) + AGCIntegrator[1];
    }

    Agc2 /= 4; /* Average AGC2 values */

    /* Test for good signal strength -- centre of analog carrier */
    *IsAnalog = (Agc2 < ANALOG_CARRIER_DETECT_AGC2_VALUE) ? TRUE : FALSE;

#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
    STTBX_Print(("%s IsAnalog=%u\n", identity, *IsAnalog));
#endif
    
    /* GNBvd17801-> Error Handling for any error returned during I2C operation inside the driver */
    Error |= Instance->DeviceMap.Error;
    Instance->DeviceMap.Error = ST_NO_ERROR;
    
    return(Error);
}   
#endif


/* ----------------------------------------------------------------------------
Name: demod_d0299_GetSignalQuality()

Description:
  Obtains a signal quality setting for the current lock.
    
Parameters:
    SignalQuality_p,    pointer to area to store the signal quality value.
    Ber,                pointer to area to store the bit error rate.
    
Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0299_GetSignalQuality(DEMOD_Handle_t Handle, U32  *SignalQuality_p, U32 *Ber)
{
#ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
   const char *identity = "STTUNER d0299.c demod_d0299_GetSignalQuality()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
#ifndef STTUNER_MINIDRIVER
    D0299_InstanceData_t *Instance;

    /* private driver instance data */
    Instance = D0299_GetInstFromHandle(Handle);

    /* Read noise estimations for C/N and BER */
    Drv0299_GetNoiseEstimator(&Instance->DeviceMap, Instance->IOHandle, SignalQuality_p, Ber);
    
    #ifdef STTUNER_DEBUG_MODULE_SATDRV_D0299
    STTBX_Print(("%s SignalQuality=%u Ber=%u\n", identity, *SignalQuality_p, *Ber));
    #endif
    
    /* GNBvd17801-> Error Handling for any error returned during I2C operation inside the driver */
    Error |= Instance->DeviceMap.Error;
    Instance->DeviceMap.Error = ST_NO_ERROR;
#endif