clk.c

ST5100 driver files for ST chipset

    RetErr = ClkrvGetParamDeviceId( pars_p, &DeviceId );
#endif

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_Init( DeviceId );
        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_Init */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_InvDecodeClk
 *            Invalidate PCR
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_InvDecodeClk( 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_InvDecodeClk( 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_InvDecodeClk */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_Open
 *            open Clock Recovery
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_Open( 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_Open( 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_Open */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_SetPCRSource
 *            Set PCR source for clock recovery
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_SetPCRSource( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    CLKRV_HandleId_t        HandleId;
    BOOL                    RetErr;
    S32                     PTI_ProcessStreamId;
    S32                     Lvar;

    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)
    {
        RetErr = STTST_GetInteger(pars_p, PTI_PS_AV1, &Lvar);
        PTI_ProcessStreamId = Lvar;
        if (RetErr == TRUE)
        {
            STTST_TagCurrentLine(pars_p, "expected valid ProcessStreamId");
        }
    }

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_SetPCRSource( DeviceId, HandleId, PTI_ProcessStreamId);
        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_SetPCRSource */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_SetSTCSource
 *            Set STC source for clock recovery (PCR or BASELINE)
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_SetSTCSource( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    CLKRV_HandleId_t        HandleId;
    BOOL                    RetErr;
    STCLKRV_STCSource_t     STCSource;
    S32                     Lvar;

    DeviceId = 0;
    HandleId = 0;
    RetErr = FALSE;

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

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger(pars_p, STCLKRV_STC_SOURCE_PCR, &Lvar);
        STCSource = Lvar;
        if (RetErr == TRUE)
        {
            STTST_TagCurrentLine(pars_p, "expected valid STCSource (STC_SOURCE_PCR,STC_SOURCE_BASELINE)");
        }
    }

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_SetSTCSource( DeviceId, HandleId, STCSource);
        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_SetSTCSource */

/*-------------------------------------------------------------------------
 * Function : TTCLKRV_SetSTCOffset
 *            Set STC offset
 * Input    : *pars_p, *result_sym_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
static BOOL TTCLKRV_SetSTCOffset( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    CLKRV_DeviceId_t        DeviceId;
    CLKRV_HandleId_t        HandleId;
    BOOL                    RetErr;
    S32					    STCOffset;
    S32                     Lvar;

    DeviceId = 0;
    HandleId = 0;
    RetErr = FALSE;

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

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger(pars_p, 0, &Lvar);
        STCOffset = Lvar;
        if (RetErr == TRUE)
        {
            STTST_TagCurrentLine(pars_p, "expected STC offset");
        }
    }

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_SetSTCOffset( DeviceId, HandleId, STCOffset);
        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_SetSTCOffset */

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

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

#if (TTCLKRV_MULTI_INSTANCE == TRUE)
    RetErr = ClkrvGetParamDeviceId( pars_p, &DeviceId );
#endif

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, FALSE, (S32 *)&Term );
        if (RetErr == TRUE)
        {
            STTST_TagCurrentLine(pars_p, "expected ForceTerminate TRUE/FALSE");
        }
    }

    if (RetErr == FALSE)
    {
        ErrCode = CLKRV_Term( DeviceId, Term );
        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_Term */

/*-------------------------------------------------------------------------
 * Function : CLKRV_InitCommands
 *            Definition of the macros
 *            (commands and constants to be used with Testtool)
 * Input    :
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ----------------------------------------------------------------------*/
BOOL CLKRV_InitCommand( void )
{
    BOOL RetErr = FALSE;
    U32     loop;

    RetErr |= STTST_RegisterCommand("CLK_INIT",         TTCLKRV_Init,
                                    INS_DEVICEID"Init Clock Recovery");
    RetErr |= STTST_RegisterCommand("CLK_OPEN",         TTCLKRV_Open,
                                    INS_DEVICEHANDLEID"Open Clock Recovery");
    RetErr |= STTST_RegisterCommand("CLK_CLOSE",        TTCLKRV_Close,
                                    INS_DEVICEHANDLEID"Close Clock Recovery");
    RetErr |= STTST_RegisterCommand("CLK_TERM",         TTCLKRV_Term,
                                    INS_DEVICEID"<Force> Term Clock Recovery");

    RetErr |= STTST_RegisterCommand("CLK_ENABLE",       TTCLKRV_Enable,
                                    INS_DEVICEHANDLEID"Enable Clock Recovery");
    RetErr |= STTST_RegisterCommand("CLK_DISABLE",      TTCLKRV_Disable,
                                    INS_DEVICEHANDLEID"Disable Clock Recovery");
    RetErr |= STTST_RegisterCommand("CLK_GETREV",       TTCLKRV_GetRevision,
                                    INS_DEVICEHANDLEID"Get driver revision");
    RetErr |= STTST_RegisterCommand("CLK_GETSTC",       TTCLKRV_GetSTC,
                                    INS_DEVICEHANDLEID"Get ST Clock");
    RetErr |= STTST_RegisterCommand("CLK_SETPCRSOURCE", TTCLKRV_SetPCRSource,
                                    INS_DEVICEHANDLEID"<ProcessStreamId> Set PCR source");
    RetErr |= STTST_RegisterCommand("CLK_SETSTCSOURCE", TTCLKRV_SetSTCSource,
                                    INS_DEVICEHANDLEID"<STC source> Set STC source");
    RetErr |= STTST_RegisterCommand("CLK_SETSTCOFFSET", TTCLKRV_SetSTCOffset,
                                    INS_DEVICEHANDLEID"<STC offset> Set STC offset");

    RetErr |= STTST_RegisterCommand("CLK_INVPCR",       TTCLKRV_InvDecodeClk,
                                    INS_DEVICEHANDLEID"Invalidate PCR");


    RetErr |= STTST_AssignInteger("STC_SOURCE_PCR", STCLKRV_STC_SOURCE_PCR, TRUE);
    RetErr |= STTST_AssignInteger("STC_SOURCE_BASELINE", STCLKRV_STC_SOURCE_BASELINE, TRUE);

    for ( loop = 0 ; loop < CLKRV_MAXDEVICE ; loop++ )
    {
        RetErr |= STTST_AssignInteger(CLKRV_GET_DEVICENAME(loop), loop, TRUE);
    }

    STTBX_Print(("CLKRV_InitCommand() : macros registrations "));
    if ( RetErr == TRUE )
    {
        STTBX_Print(("failure !\n"));
    }
    else
    {
        STTBX_Print(("ok\n"));
    }

    return( RetErr ); 

} /* end CLKRV_InitCommand */

#endif /* TESTTOOL */

/* EOF */