d0297j.c

st7710的tuner标准驱动

/* ----------------------------------------------------------------------------
Name: demod_d0297J_GetFECRates()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0297J_GetFECRates(DEMOD_Handle_t Handle, STTUNER_FECRate_t *FECRates)
{
    ST_ErrorCode_t Error = ST_ERROR_FEATURE_NOT_SUPPORTED;
    return(Error);
}



/* ----------------------------------------------------------------------------
Name: demod_d0297J_IsLocked()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0297J_IsLocked(DEMOD_Handle_t Handle, BOOL *IsLocked)
{
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
   const char *identity = "STTUNER d0297J.c demod_d0297J_IsLocked()";
#endif
    ST_ErrorCode_t          Error = ST_NO_ERROR;
    U8                      Version;
    D0297J_InstanceData_t    *Instance;
    D0297J_SignalType_t      SignalType;

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

    *IsLocked = FALSE;

    /*
    --- Get Version Id (In fact to test I2C Access
    */
    Version = Reg0297J_GetSTV0297JId(&Instance->DeviceMap, Instance->IOHandle);
    if ( Version !=  STV0297J_DEVICE_VERSION)
    {
        return(ST_ERROR_UNKNOWN_DEVICE);
    }

    /*
    --- Get Information from demod
    */
    SignalType = Drv0297J_CheckAgc(&Instance->DeviceMap, Instance->IOHandle, &Instance->StateBlock.Params);
    if (SignalType == E297J_AGCOK)
    {
        SignalType = Drv0297J_CheckData(&Instance->DeviceMap, Instance->IOHandle, &Instance->StateBlock.Params);
        if (SignalType == E297J_DATAOK)
        {
            Instance->StateBlock.Result.SignalType = E297J_LOCKOK;
            *IsLocked = TRUE;
        }
        else
        {
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
            STTBX_Print(("%s FRONT END IS UNLOCKED !!!! NO DATA\n", identity));
#endif
            /*
            --- Update Satus
            */
            Instance->StateBlock.Result.SignalType = SignalType;
        }
    }
    else
    {
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s FRONT END IS UNLOCKED !!!! NO AGC\n", identity));
#endif
        /*
        --- Update Satus
        */
        Instance->StateBlock.Result.SignalType = SignalType;
    }

/*
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
    STTBX_Print(("%s TUNER IS %s\n", identity, (*IsLocked)?"LOCKED":"UNLOCKED"));
#endif
*/

    Error |= Instance->DeviceMap.Error;
    Instance->DeviceMap.Error = ST_NO_ERROR;

    return(Error);
}



/* ----------------------------------------------------------------------------
Name: demod_d0297J_SetFECRates()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0297J_SetFECRates(DEMOD_Handle_t Handle, STTUNER_FECRate_t FECRates)
{
    ST_ErrorCode_t Error = ST_ERROR_FEATURE_NOT_SUPPORTED;
    return(Error);
}



/* ----------------------------------------------------------------------------
Name: demod_d0297J_Tracking()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0297J_Tracking(DEMOD_Handle_t Handle, BOOL ForceTracking, U32 *NewFrequency, BOOL *SignalFound)
{
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
   const char *identity = "STTUNER d0297J.c demod_d0297J_Tracking()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;

    STTUNER_tuner_instance_t    *TunerInstance;     /* don't really need all these variables, done for clarity */
    STTUNER_InstanceDbase_t     *Inst;              /* pointer to instance database */
    STTUNER_Handle_t            TopHandle;          /* instance that contains the demos, tuner, lnb & diseqc driver set */
    D0297J_InstanceData_t        *Instance;
    BOOL                        IsLocked, DataFound;

    /* private driver instance data */
    Instance = D0297J_GetInstFromHandle(Handle);
    /* top level public instance data */
    Inst = STTUNER_GetDrvInst();

    /* this driver knows what to level instance it belongs to */
    TopHandle = Instance->TopLevelHandle;

    /* get the tuner instance for this driver from the top level handle */
    TunerInstance = &Inst[TopHandle].Cable.Tuner;

    /*
    --- Get Carrier And Data (TS) status
    */
    Error = demod_d0297J_IsLocked(Handle, &IsLocked);
    if ( Error == ST_NO_ERROR && IsLocked )
    {
        /*
        --- Tuner Is Locked
        */
        *SignalFound  = (Instance->StateBlock.Result.SignalType == E297J_LOCKOK)? TRUE : FALSE;
        *NewFrequency = 1000 * ((U32)Instance->StateBlock.Result.Frequency);
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s FRONT END IS LOCKED on %d Hz (CARRIER and DATA)\n", identity, *NewFrequency));
#endif
    }
    else
    {
        /*
        --- Tuner is UnLocked => Search Carrier and Data
        */
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s FRONT END IS UNLOCKED ==> SEARCH CARRIER AND DATA\n", identity));
#endif
        DataFound = Driv0297JCarrierSearch(&Instance->DeviceMap, Instance->IOHandle, &Instance->StateBlock, TunerInstance);
        Error |= Instance->DeviceMap.Error;
        Instance->DeviceMap.Error = ST_NO_ERROR;
        if (Error != ST_NO_ERROR)
        {
            return(Error);
        }

        if (DataFound)
        {
            *SignalFound  = (Instance->StateBlock.Result.SignalType == E297J_LOCKOK)? TRUE : FALSE;
            *NewFrequency = 1000 * ((U32)Instance->StateBlock.Result.Frequency);
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
            STTBX_Print(("%s DATA on %d Hz\n", identity, *NewFrequency));
#endif
        }
        else
        {
            /*
            --- Tuner Is UnLocked
            */
            *SignalFound  = FALSE;
            *NewFrequency = 1000 * ((U32)Instance->StateBlock.Result.Frequency);
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
            STTBX_Print(("%s NO DATA on %d Hz !!!!\n", identity, *NewFrequency));
#endif
        }
    }

#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
    STTBX_Print(("%s %s, on %u Hz\n", identity, (*SignalFound)?"SIGNAL FOUND":"NO SIGNAL DOUND", *NewFrequency));
#endif

    Error |= Instance->DeviceMap.Error;
    Instance->DeviceMap.Error = ST_NO_ERROR;

    return(Error);
}



/* ----------------------------------------------------------------------------
Name: demod_d0297J_ScanFrequency()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0297J_ScanFrequency(DEMOD_Handle_t Handle, U32  InitialFrequency, U32   SymbolRate,    U32   MaxOffset,
                                                                U32  TunerStep,        U8    DerotatorStep, BOOL *ScanSuccess,
                                                                U32 *NewFrequency,     U32   Mode,          U32   Guard,
                                                                U32  Force,            U32   Hierarchy,     U32   Spectrum,
                                                                U32  FreqOff,          U32   ChannelBW,     S32   EchoPos)
{
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
    clock_t                     time_start_lock, time_end_lock;
   const char *identity = "STTUNER d0297J.c demod_d0297J_ScanFrequency()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    STTUNER_tuner_instance_t    *TunerInstance;
    STTUNER_InstanceDbase_t     *Inst;
    D0297J_InstanceData_t        *Instance;
    BOOL                        DataFound=FALSE;

    /* private driver instance data */
    Instance = D0297J_GetInstFromHandle(Handle);
    /* top level public instance data */
    Inst = STTUNER_GetDrvInst();

    /* get the tuner instance for this driver from the top level handle */
    TunerInstance = &Inst[Instance->TopLevelHandle].Cable.Tuner;

    /*STTUNER_task_lock();*/

    /*
    --- Spectrum inversion is set to
    */
    switch(Spectrum)
    {
        case STTUNER_INVERSION_NONE :
        case STTUNER_INVERSION :
        case STTUNER_INVERSION_AUTO :
            break;
        default:
            Inst[Instance->TopLevelHandle].Cable.SingleScan.Spectrum = STTUNER_INVERSION_NONE;
            break;
    }

    /*
    --- Modulation type is set to
    */
    switch(Inst[Instance->TopLevelHandle].Cable.Modulation)
    {
        case STTUNER_MOD_16QAM :
        case STTUNER_MOD_32QAM :
        case STTUNER_MOD_64QAM :
        case STTUNER_MOD_128QAM :
        case STTUNER_MOD_256QAM :
            break;
        case STTUNER_MOD_QAM :
        default:
            Inst[Instance->TopLevelHandle].Cable.Modulation = STTUNER_MOD_64QAM;
            break;
    }

    /*
    --- Start Init
    */
    Drv0297J_InitSearch(TunerInstance, &Instance->StateBlock,
                       Inst[Instance->TopLevelHandle].Cable.Modulation,
                       InitialFrequency,
                       SymbolRate,
                       Spectrum,
                       Inst[Instance->TopLevelHandle].Cable.ScanExact,
                       Inst[Instance->TopLevelHandle].Cable.SingleScan.J83);

    /*
    --- Try to lock
    */
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
    time_start_lock = time_now();
#endif
    DataFound = Driv0297JCarrierSearch(&Instance->DeviceMap,Instance->IOHandle, &Instance->StateBlock, TunerInstance);
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
    time_end_lock = time_now();
#endif
    if (DataFound)
    {
        /*Instance->StateBlock.Result.SignalType = E297J_LOCKOK;*/
        /* Pass new frequency to caller */
        *NewFrequency = 1000 * ((U32)Instance->StateBlock.Result.Frequency);
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s  DATA FOUND on %u Hz\n", identity, *NewFrequency));
#endif
        *ScanSuccess = TRUE;
    }
    else
    {
        Instance->StateBlock.Result.SignalType = E297J_NODATA;
        *NewFrequency = InitialFrequency;
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s NO DATA on %u Hz\n", identity, *NewFrequency));
#endif
        *ScanSuccess = FALSE;
    }

    /*STTUNER_task_unlock();*/

#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
    switch(Inst[Instance->TopLevelHandle].Cable.Modulation)
    {
        case STTUNER_MOD_16QAM :
            STTBX_Print(("%s QAM 16 : ", identity));
            break;
        case STTUNER_MOD_32QAM :
            STTBX_Print(("%s QAM 32 : ", identity));
            break;
        case STTUNER_MOD_64QAM :
            STTBX_Print(("%s QAM 64 : ", identity));
            break;
        case STTUNER_MOD_128QAM :
            STTBX_Print(("%s QAM 128 : ", identity));
            break;
        case STTUNER_MOD_256QAM :
            STTBX_Print(("%s QAM 256 : ", identity));
            break;
        case STTUNER_MOD_QAM :
            STTBX_Print(("%s QAM : ", identity));
            break;
    }
    STTBX_Print(("SR %d S/s TIME >> TUNER + DEMOD (%u ticks)(%u ms)\n", SymbolRate,
                time_minus(time_end_lock, time_start_lock),
                ((time_minus(time_end_lock, time_start_lock))*1000)/ST_GetClocksPerSecond()
                ));
#endif

    Error |= Instance->DeviceMap.Error;
    Instance->DeviceMap.Error = ST_NO_ERROR;

    return(Error);
}

/* ----------------------------------------------------------------------------
Name: demod_d0297J_ioctl()

Description:
    access device specific low-level functions

Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0297J_ioctl(DEMOD_Handle_t Handle, U32 Function, void *InParams, void *OutParams, STTUNER_Da_Status_t *Status)
{
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
   const char *identity = "STTUNER d0297J.c demod_d0297J_ioctl()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    D0297J_InstanceData_t *Instance;

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

    if(STTUNER_Util_CheckPtrNull(Instance) != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s invalid handle\n", identity));
#endif
        return(ST_ERROR_INVALID_HANDLE);
    }

#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s demod driver instance handle=%d\n", identity, Handle));
        STTBX_Print(("%s                     function=%d\n", identity, Function));
        STTBX_Print(("%s                   I/O handle=%d\n", identity, Instance->IOHandle));
#endif

    /* ---------- select what to do ---------- */
    switch(Function){

        case STTUNER_IOCTL_REG_IN: /* read device register */
            *(int *)OutParams = STTUNER_IOREG_GetRegister(&Instance->DeviceMap, Instance->IOHandle, *(int *)InParams);
            break;

        case STTUNER_IOCTL_REG_OUT: /* write device register */
            Error =  STTUNER_IOREG_SetRegister(  &Instance->DeviceMap,
                                                  Instance->IOHandle,
                  ((CABIOCTL_SETREG_InParams_t *)InParams)->RegIndex,
                  ((CABIOCTL_SETREG_InParams_t *)InParams)->Value );
            break;

        default:
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
            STTBX_Print(("%s function %d not found\n", identity, Function));
#endif
            return(ST_ERROR_FEATURE_NOT_SUPPORTED);
    }


#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
    STTBX_Print(("%s called ok\n", identity, Function));    /* signal that function came back */
#endif

    Error |= Instance->DeviceMap.Error; /* Also accumulate I2C error */
    Instance->DeviceMap.Error = ST_NO_ERROR;

    return(Error);

}



/* ----------------------------------------------------------------------------
Name: demod_d0297J_ioaccess()

Description:
    called from ioarch.c when some driver does I/O but with the repeater/passthru
    set to point to this function.
Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t demod_d0297J_ioaccess(DEMOD_Handle_t Handle, IOARCH_Handle_t IOHandle, STTUNER_IOARCH_Operation_t Operation, U16 SubAddr, U8 *Data, U32 TransferSize, U32 Timeout)
{
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
   const char *identity = "STTUNER d0297J.c demod_d0297J_ioaccess()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    IOARCH_Handle_t ThisIOHandle;
    D0297J_InstanceData_t *Instance;

    Instance = D0297J_GetInstFromHandle(Handle);

    if(STTUNER_Util_CheckPtrNull(Instance) != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s invalid handle\n", identity));
#endif
        return(ST_ERROR_INVALID_HANDLE);
    }

    /* this (demod) drivers I/O handle */
    ThisIOHandle = Instance->IOHandle;

    /* if STTUNER_IOARCH_MAX_HANDLES then passthrough function required using our device handle/address */
    if (IOHandle == STTUNER_IOARCH_MAX_HANDLES)
    {
/*
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s write passthru\n", identity));
#endif
*/
        Error = STTUNER_IOARCH_ReadWrite(ThisIOHandle, Operation, SubAddr, Data, TransferSize, Timeout);
    }
    else    /* repeater */
    {
/*
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J
        STTBX_Print(("%s write repeater\n", identity));
#endif
*/
        STTUNER_task_lock();    /* prevent any other activity on this bus (no task must preempt us) */
        #ifdef PROCESSOR_C1 /***For C1 core this delay needed otherwise STTUNER_task_lock(); not working fine ****/
        task_delay(5);
        #endif
        /* enable repeater then send the data  using I/O handle supplied through ioarch.c */
        Error = STTUNER_IOREG_SetField(& Instance->DeviceMap, ThisIOHandle, F0297J_I2CT_EN, 1);
        if ( Error == ST_NO_ERROR )
        {
            /*
            --- Send/Receive Data(s) to target at SubAddr
            */
            Error = STTUNER_IOARCH_ReadWriteNoRep(IOHandle, Operation, SubAddr, Data, TransferSize, Timeout*100);
        }
        STTUNER_task_unlock();
    }

    return(Error);
}



/* ------------------------------------------------------------------------- */
/* /\/\/\/\/\/\/\/\/\/\/\/\/\UTILITY Functions/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ */
/* ------------------------------------------------------------------------- */

D0297J_InstanceData_t *D0297J_GetInstFromHandle(DEMOD_Handle_t Handle)
{
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J_HANDLES
   const char *identity = "STTUNER d0297J.c D0297J_GetInstFromHandle()";
#endif
    D0297J_InstanceData_t *Instance;

    Instance = (D0297J_InstanceData_t *)Handle;
#ifdef STTUNER_DEBUG_MODULE_CABDRV_D0297J_HANDLES
    STTBX_Print(("%s block at 0x%08x\n", identity, Instance));
#endif

    return(Instance);
}




/* End of d0297J.c */