clk.c

ST5100 driver files for ST chipset

    PCRSource.Source = STCLKRV_PCR_SOURCE_PTI;
    ErrCode = PTI_PCRGetSlotHandle(CLKRV_GET_PTIDEVICEID(DeviceId), PTI_ProcessStreamId,
                         &SlotHandle);
    if (ErrCode != ST_NO_ERROR)
    {
        ReportLevel = STTBX_REPORT_LEVEL_ERROR;
    }
    if (ErrCode == ST_NO_ERROR)
    {
        PCRSource.Source_u.STPTI_s.Slot = SlotHandle;
        ErrCode =  STCLKRV_SetPCRSource(CLKRV_GET_HANDLE(DeviceId, HandleId), &PCRSource);
        if ( ErrCode == ST_NO_ERROR )
        {
            ReportLevel = STTBX_REPORT_LEVEL_INFO;
        }
    }

    STTBX_Report((ReportLevel,"STCLKRV_SetPCRSource(%s)=%s", CLKRV_GET_DEVICENAME(DeviceId),
                  GetErrorText(ErrCode)));

    return ( ErrCode );

} /* end CLKRV_SetPCRSource */

/*-------------------------------------------------------------------------
 * Function : CLKRV_SetSTCSource
 *            Set PCR source for Clock Recovery
 * Input    : DeviceId, HandleId, STCSource
 * Output   :
 * Return   : Error Code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t CLKRV_SetSTCSource( CLKRV_DeviceId_t DeviceId, CLKRV_HandleId_t HandleId, STCLKRV_STCSource_t STCSource)
{
    ST_ErrorCode_t          ErrCode;
    STTBX_ReportLevel_t     ReportLevel;

    ErrCode     = ST_NO_ERROR;
    ReportLevel = STTBX_REPORT_LEVEL_ERROR;

    if (HandleId >= CLKRV_MAXOPEN)
    {
        ErrCode = ST_ERROR_BAD_PARAMETER;
    }
    if ( CLKRV_GET_HANDLE(DeviceId,HandleId) == CLKRV_HANDLE_NULL )
    {
        ErrCode = ST_ERROR_BAD_PARAMETER;
    }

    if (ErrCode == ST_NO_ERROR)
    {
        ErrCode =  STCLKRV_SetSTCSource(CLKRV_GET_HANDLE(DeviceId, HandleId), STCSource);
        if ( ErrCode == ST_NO_ERROR )
        {
            ReportLevel = STTBX_REPORT_LEVEL_INFO;
        }
    }

    STTBX_Report((ReportLevel,"STCLKRV_SetSTCSource(%s)=%s", CLKRV_GET_DEVICENAME(DeviceId),
                  GetErrorText(ErrCode)));

    return ( ErrCode );

} /* end CLKRV_SetSTCSource */

/*-------------------------------------------------------------------------
 * Function : CLKRV_SetSTCOffset
 *            Set STC offset
 * Input    : DeviceId, HandleId, STC_Offset
 * Output   :
 * Return   : Error Code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t CLKRV_SetSTCOffset( CLKRV_DeviceId_t DeviceId, CLKRV_HandleId_t HandleId, S32 STC_Offset)
{
    ST_ErrorCode_t          ErrCode;
    STTBX_ReportLevel_t     ReportLevel;

    ErrCode     = ST_NO_ERROR;
    ReportLevel = STTBX_REPORT_LEVEL_ERROR;

    if (HandleId >= CLKRV_MAXOPEN)
    {
        ErrCode = ST_ERROR_BAD_PARAMETER;
    }
    if ( CLKRV_GET_HANDLE(DeviceId,HandleId) == CLKRV_HANDLE_NULL )
    {
        ErrCode = ST_ERROR_BAD_PARAMETER;
    }

    if (ErrCode == ST_NO_ERROR)
    {
        ErrCode =  STCLKRV_SetSTCOffset(CLKRV_GET_HANDLE(DeviceId, HandleId), STC_Offset);
        if ( ErrCode == ST_NO_ERROR )
        {
            ReportLevel = STTBX_REPORT_LEVEL_INFO;
        }
    }

    STTBX_Report((ReportLevel,"STCLKRV_SetSTCOffset(%s,%d)=%s", CLKRV_GET_DEVICENAME(DeviceId),
                  (int)STC_Offset, GetErrorText(ErrCode)));

    return ( ErrCode );

} /* end CLKRV_SetSTCOffset */

/*-------------------------------------------------------------------------
 * Function : CLKRV_Term
 *            terminate Clock Recovery
 * Input    : DeviceId, ForceTerminate
 * Output   :
 * Return   : Error Code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t CLKRV_Term( CLKRV_DeviceId_t DeviceId, BOOL ForceTerminate )
{
    ST_ErrorCode_t          ErrCode;
    STTBX_ReportLevel_t     ReportLevel;
    STCLKRV_TermParams_t    TermParams;

    ErrCode     = ST_NO_ERROR;
    ReportLevel = STTBX_REPORT_LEVEL_ERROR;

    TermParams.ForceTerminate = ForceTerminate;

    ErrCode = STCLKRV_Term(CLKRV_GET_DEVICENAME(DeviceId), &TermParams);
    if ( ErrCode == ST_NO_ERROR )
    {
        ReportLevel = STTBX_REPORT_LEVEL_INFO;
    }

    STTBX_Report((ReportLevel,"STCLKRV_Term(%s)=%s", CLKRV_GET_DEVICENAME(DeviceId),
                  GetErrorText(ErrCode)));

    return ( ErrCode );

} /* end CLKRV_Term */

/* Testtool Functions --------------------------------------------------- */

#ifdef TESTTOOL

#if (TTCLKRV_MULTI_INSTANCE == TRUE)
/*-------------------------------------------------------------------------
 * Function : ClkrvGetParamDeviceId
 *            Get clkrv DeviceId
 * Input    : pars_p
 * Output   : *DeviceId_p
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL ClkrvGetParamDeviceId( parse_t *pars_p, CLKRV_DeviceId_t *DeviceId_p )
{
        BOOL RetErr;

        RetErr = STTST_GetInteger(pars_p, 0, (S32 *)DeviceId_p);
        if ( (RetErr == TRUE) || (*DeviceId_p>=CLKRV_MAXDEVICE) )
        {
                STTBX_Print(("Invalid DeviceId\n"));
                RetErr = TRUE;
        }

        return RetErr;
} /* ClkrvGetParamDeviceId() */

/*-------------------------------------------------------------------------
 * Function : ClkrvGetParamHandleId
 *            Get clkrv HandleId
 * Input    : pars_p
 * Output   : *HandleId_p
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL ClkrvGetParamHandleId( parse_t *pars_p, CLKRV_HandleId_t *HandleId_p )
{
        BOOL RetErr;

        RetErr = STTST_GetInteger(pars_p, 0, (S32 *)HandleId_p);
        if ( (RetErr == TRUE) || (*HandleId_p>=CLKRV_MAXOPEN) )
        {
                STTBX_Print(("Invalid HandleId\n"));
                RetErr = TRUE;
        }

        return RetErr;
} /* ClkrvGetParamHandleId() */

#endif /* TTCLKRV_MULTI_INSTANCE */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_Close
 *            close Clock Recovery
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_Close( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    CLKRV_HandleId_t        HandleId;
    BOOL                    RetErr;

    DeviceId = 0;
    HandleId = 0;
    RetErr   = FALSE;
    ErrCode  = ST_NO_ERROR;

#if (TTCLKRV_MULTI_INSTANCE == TRUE)
    RetErr = ClkrvGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = ClkrvGetParamHandleId( pars_p, &HandleId );
    }
#endif

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_Close( DeviceId, HandleId );
        if (ErrCode != ST_NO_ERROR)
        {
            RetErr = TRUE;
        }
    }

    if (RetErr == TRUE)
    {
        API_ErrorCount++;
    }

    STTST_AssignInteger(result_sym_p, RetErr, FALSE);
    return ( API_EnableError ? RetErr : FALSE );

} /* end TTCLKRV_Close */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_Disable
 *            Disable Clock Recovery
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_Disable( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    CLKRV_HandleId_t        HandleId;
    BOOL                    RetErr;

    DeviceId = 0;
    HandleId = 0;
    RetErr   = FALSE;
    ErrCode  = ST_NO_ERROR;

#if (TTCLKRV_MULTI_INSTANCE == TRUE)
    RetErr = ClkrvGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = ClkrvGetParamHandleId( pars_p, &HandleId );
    }
#endif

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_Disable( DeviceId, HandleId );
        if (ErrCode != ST_NO_ERROR)
        {
            RetErr = TRUE;
        }
    }

    if (RetErr == TRUE)
    {
        API_ErrorCount++;
    }

    STTST_AssignInteger(result_sym_p, RetErr, FALSE);
    return ( API_EnableError ? RetErr : FALSE );

} /* end TTCLKRV_Disable */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_Enable
 *            Enable Clock Recovery
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_Enable( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    CLKRV_HandleId_t        HandleId;
    BOOL                    RetErr;

    DeviceId = 0;
    HandleId = 0;
    RetErr   = FALSE;
    ErrCode  = ST_NO_ERROR;

#if (TTCLKRV_MULTI_INSTANCE == TRUE)
    RetErr = ClkrvGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = ClkrvGetParamHandleId( pars_p, &HandleId );
    }
#endif

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_Enable( DeviceId, HandleId );
        if (ErrCode != ST_NO_ERROR)
        {
            RetErr = TRUE;
        }
    }

    if (RetErr == TRUE)
    {
        API_ErrorCount++;
    }

    STTST_AssignInteger(result_sym_p, RetErr, FALSE);
    return ( API_EnableError ? RetErr : FALSE );

} /* end TTCLKRV_Enable */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_GetSTC
 *            Get STC
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_GetSTC( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    CLKRV_HandleId_t        HandleId;
    BOOL                    RetErr;
    U32                     STCvalue;

    DeviceId = 0;
    HandleId = 0;
    RetErr   = FALSE;
    ErrCode  = ST_NO_ERROR;

#if (TTCLKRV_MULTI_INSTANCE == TRUE)
    RetErr = ClkrvGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = ClkrvGetParamHandleId( pars_p, &HandleId );
    }
#endif

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_GetSTC( DeviceId, HandleId, &STCvalue );
        if (ErrCode != ST_NO_ERROR)
        {
            RetErr = TRUE;
        }
    }

    if (RetErr == TRUE)
    {
        API_ErrorCount ++;
    }

    STTST_AssignInteger(result_sym_p, STCvalue, FALSE);
    return ( API_EnableError ? RetErr : FALSE );

} /* end TTCLKRV_GetSTC */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_GetRevision
 *            Get driver revision number
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_GetRevision( parse_t *pars_p, char *result_sym_p )
{
    ST_Revision_t RevisionNumber;

    RevisionNumber = STCLKRV_GetRevision();
    STTBX_Print(("STCLKRV_GetRevision()=%s\n", RevisionNumber ));

    return ( FALSE );

} /* end TTCLKRV_GetRevision */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_Init
 *            initialise Clock Recovery
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_Init( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    BOOL                    RetErr;

    DeviceId = 0;
    RetErr   = FALSE;
    ErrCode  = ST_NO_ERROR;

#if (TTCLKRV_MULTI_INSTANCE == TRUE)