vtg.c

ST5100 driver files for ST chipset

    ST_Revision_t RevisionNumber;

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

    return ( FALSE );

} /* end TTVTG_GetRevision */

/*-------------------------------------------------------------------------------
 * Function : TTVTG_Init
 *            initialise VTG
 * Input    : None
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * ---------------------------------------------------------------------------- */
static BOOL TTVTG_Init( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    VTG_DeviceId_t          DeviceId;
    VTG_HandleId_t          HandleId;
    BOOL                    RetErr;
	S32						Lvar;

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

#if (TTVTG_MULTI_INSTANCE == TRUE)
    RetErr = VtgGetParamDeviceId( pars_p, &DeviceId );
#endif

	if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0, (S32 *)&Lvar);
        if( RetErr || (Lvar > 2) )
        {
            STTBX_Print(("expected default clock (0: HD - 148.5 mhz, 1: SD - 27mhz)\n"));
            RetErr = TRUE;
        }
    }

    if (ErrCode == FALSE)
    {
        ErrCode = VTG_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 TTVTG_Init */

/*-------------------------------------------------------------------------------
 * Function : TTVTG_Open
 *            open VTG
 * Input    : None
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_Open(  parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    VTG_DeviceId_t          DeviceId;
    VTG_HandleId_t          HandleId;
    BOOL                    RetErr;

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

#if (TTVTG_MULTI_INSTANCE == TRUE)
    RetErr = VtgGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = VtgGetParamHandleId( pars_p, &HandleId );
    }
#endif

    if (RetErr == FALSE)
    {
        ErrCode = VTG_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 TTVTG_Open */

/*-------------------------------------------------------------------------------
 * Function : TTVTG_SetMode
 *            Set VTG Mode
 * Input    : *pars_p, *result_sym_p_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_SetMode( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    STVTG_TimingMode_t      TimingMode;
    VTG_DeviceId_t          DeviceId;
    VTG_HandleId_t          HandleId;
    BOOL                    RetErr;
    U32                     index;

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

#if (TTVTG_MULTI_INSTANCE == TRUE)
    RetErr = VtgGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = VtgGetParamHandleId( pars_p, &HandleId );
    }
#endif

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0xFF,
                                   (S32 *)&TimingMode);
        if( (RetErr==TRUE) || (TimingMode==0xFF) )
        {
            STTBX_Print(("Expected a valid mode\n"));
            for (index = 0; index <VTG_MAX_MODE; index ++)
            {
                STTBX_Print(("\t%s\t: %d\n",VTG_ModeName[index].Name,
                             VTG_ModeName[index].Num));
            }
            RetErr = TRUE;
        }
    }

    if (RetErr == FALSE)
    {
        ErrCode = VTG_SetMode( DeviceId, HandleId, TimingMode );
        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 TTVTG_SetMode */


/*-------------------------------------------------------------------------------
 * Function : TTVTG_SetOptionalConfiguration
 *            Set VTG Optionnal Configuration
 * Input    : *pars_p, *result_sym_p_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_SetOptionalConfiguration( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t                ErrCode;
    STVTG_OptionalConfiguration_t VTGOption;
    VTG_DeviceId_t                DeviceId;
    VTG_HandleId_t                HandleId;
    BOOL                          RetErr;
    S32                           Lvar;

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

#if (TTVTG_MULTI_INSTANCE == TRUE)
    RetErr = VtgGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = VtgGetParamHandleId( pars_p, &HandleId );
    }
#endif

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0xFF, &Lvar);
        switch (Lvar)
        {
            case STVTG_OPTION_EMBEDDED_SYNCHRO:
            {
                VTGOption.Option = Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Expected Embeded synchro TRUE/FALSE\n"));
                }
                VTGOption.Value.EmbeddedSynchro = (BOOL)Lvar;
                break;
            }
            case STVTG_OPTION_NO_OUTPUT_SIGNAL:
            {
                VTGOption.Option =  Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Expected No Output Signal TRUE/FALSE\n"));
                }
                VTGOption.Value.NoOutputSignal = (BOOL)Lvar;
                break;
            }
            case STVTG_OPTION_HSYNC_POLARITY:
            {
                VTGOption.Option = Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Embeded Is HSync Positive TRUE/FALSE\n"));
                }
                VTGOption.Value.IsHSyncPositive = (BOOL)Lvar;
                break;
            }
            case STVTG_OPTION_VSYNC_POLARITY:
            {
                VTGOption.Option = Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Expected Is VSync Positive TRUE/FALSE\n"));
                }
                VTGOption.Value.IsVSyncPositive = (BOOL)Lvar;
                break;
            }
            case STVTG_OPTION_OUT_EDGE_POSITION:
            {
                VTGOption.Option = Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Expected HSync Rising Edge\n"));
                }
                VTGOption.Value.OutEdges.HSyncRising = (U32)Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Expected HSync Falling Edge\n"));
                }
                VTGOption.Value.OutEdges.HSyncFalling = (U32)Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Expected VSync Rising Edge\n"));
                }
                VTGOption.Value.OutEdges.VSyncRising = (U32)Lvar;
                RetErr = STTST_GetInteger( pars_p, 0x0, &Lvar);
                if (RetErr == TRUE)
                {
                    STTBX_Print((" Expected VSync Falling Edge\n"));
                }
                VTGOption.Value.OutEdges.VSyncFalling = (U32)Lvar;
                break;
            }
            default:
            {
                STTBX_Print(("Expected a valid Option :\n"));
                STTBX_Print(("\t EMBEDDED_SYNCHRO  : %d\n", STVTG_OPTION_EMBEDDED_SYNCHRO));
                STTBX_Print(("\t NO_OUTPUT_SIGNAL  : %d\n", STVTG_OPTION_NO_OUTPUT_SIGNAL));
                STTBX_Print(("\t HSYNC_POLARITY    : %d\n", STVTG_OPTION_HSYNC_POLARITY));
                STTBX_Print(("\t VSYNC_POLARITY    : %d\n", STVTG_OPTION_VSYNC_POLARITY));
                STTBX_Print(("\t OUT_EDGE_POSITION : %d\n", STVTG_OPTION_OUT_EDGE_POSITION));
                RetErr = TRUE;
            }
        } /* switch (Lvar) */
    }

    if (RetErr == FALSE)
    {
        ErrCode = VTG_SetOptionalConfiguration(DeviceId, HandleId, &VTGOption);
        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 TTVTG_SetOptionalConfiguration */


/*-------------------------------------------------------------------------------
 * Function : TTVTG_SetSlaveModeParams
 *            Set VTG Slave Mode Parameters
 * Input    : *pars_p, *result_sym_p_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_SetSlaveModeParams( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    STVTG_SlaveModeParams_t SlaveModeParams;
    S32                     Lvar;
    VTG_DeviceId_t          DeviceId;
    VTG_HandleId_t          HandleId;
    BOOL                    RetErr;

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

#if (TTVTG_MULTI_INSTANCE == TRUE)
    RetErr = VtgGetParamDeviceId( pars_p, &DeviceId );
    if( RetErr == FALSE)
    {
        RetErr = VtgGetParamHandleId( pars_p, &HandleId );
    }
#endif