vtg.c

ST5100 driver files for ST chipset

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, -1, (S32 *)&Lvar);
        if( RetErr || (Lvar!=STVTG_SLAVE_MODE_H_AND_V &&
                       Lvar!=STVTG_SLAVE_MODE_V_ONLY &&
                       Lvar!=STVTG_SLAVE_MODE_H_ONLY) )
        {
            STTBX_Print(("expected a valid Slave Mode (VTGSM_H_AND_V,VTGSM_H,VTGSM_V)\n"));
            RetErr = TRUE;
        }
        SlaveModeParams.SlaveMode = Lvar;
    }

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, -1, (S32 *)&Lvar);
        if( RetErr || (Lvar!=STVTG_SLAVE_OF_PIN &&
                       Lvar!=STVTG_SLAVE_OF_REF &&
                       Lvar!=STVTG_SLAVE_OF_SDIN1 &&
                       Lvar!=STVTG_SLAVE_OF_SDIN2 &&
                       Lvar!=STVTG_SLAVE_OF_HDIN) )
        {
            STTBX_Print(("expected a valid source of H input (VTGSOF_PIN,VTGSOF_REF,VTGSOF_SDIN1,VTGSOF_SDIN2,VTGSOF_HDIN)\n"));
            RetErr = TRUE;
        }
        SlaveModeParams.Target.VtgCell.HSlaveOf = Lvar;
    }

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, -1, (S32 *)&Lvar);
        if( RetErr || (Lvar!=STVTG_SLAVE_OF_PIN &&
                       Lvar!=STVTG_SLAVE_OF_REF &&
                       Lvar!=STVTG_SLAVE_OF_SDIN1 &&
                       Lvar!=STVTG_SLAVE_OF_SDIN2 &&
                       Lvar!=STVTG_SLAVE_OF_HDIN) )
        {
            STTBX_Print(("expected a valid source of V input (VTGSOF_PIN,VTGSOF_REF,VTGSOF_SDIN1,VTGSOF_SDIN2,VTGSOF_HDIN)\n"));
            RetErr = TRUE;
        }
        SlaveModeParams.Target.VtgCell.VSlaveOf = Lvar;
    }

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0, (S32 *)&Lvar);
        if( RetErr )
        {
            STTBX_Print(("expected a valid BottomFieldDetectMin\n"));
            RetErr = TRUE;
        }
        SlaveModeParams.Target.VtgCell.BottomFieldDetectMin = Lvar;
    }

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0, (S32 *)&Lvar);
        if( RetErr )
        {
            STTBX_Print(("expected a valid BottomFieldDetectMax\n"));
            RetErr = TRUE;
        }
        SlaveModeParams.Target.VtgCell.BottomFieldDetectMax = Lvar;
    }

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0, (S32 *)&Lvar);
        if( RetErr || (Lvar!=STVTG_EXT_VSYNC_SHAPE_BNOTT && Lvar!=STVTG_EXT_VSYNC_SHAPE_PULSE) )
        {
            STTBX_Print(("expected a valid External Vsync shape signal (VTGEXTVSHAPE_BNOTT,VTGEXTVSHAPE_PULSE)\n"));
	    RetErr = TRUE;
        }
        SlaveModeParams.Target.VtgCell.ExtVSyncShape = Lvar;
    }

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0, (S32 *)&Lvar);
        if( RetErr )
        {
            STTBX_Print(("expected a valid boolean for ExtVSyncRisingEdge\n"));
            RetErr = TRUE;
        }
        SlaveModeParams.Target.VtgCell.IsExtVSyncRisingEdge = Lvar;
    }

    if (RetErr == FALSE)
    {
        RetErr = STTST_GetInteger( pars_p, 0, (S32 *)&Lvar);
        if( RetErr )
        {
            STTBX_Print(("expected a valid boolean for ExtHSyncRisingEdge\n"));
            RetErr = TRUE;
        }
        SlaveModeParams.Target.VtgCell.IsExtHSyncRisingEdge = Lvar;
    }

    if (RetErr == FALSE)
    {
        ErrCode = VTG_SetSlaveModeParams( DeviceId, HandleId, &SlaveModeParams );
        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_SetSlaveModeParams */

/*-------------------------------------------------------------------------------
 * Function : TTVTG_Term
 *            terminate VTG
 * Input    : *pars_p, *result_sym_p_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_Term( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    BOOL                    Term;
    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)
    {
        RetErr = STTST_GetInteger( pars_p, FALSE, (S32 *)&Term );
        if (RetErr == TRUE)
        {
            STTST_TagCurrentLine(pars_p, "expected ForceTerminate TRUE/FALSE");
        }
    }

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

#if (TTVTG_DEBUG == TRUE)
/*-------------------------------------------------------------------------------
 * Function : TTVTG_VsyncStatus
 *            Display Vsync status
 * Input    : *pars_p, *result_sym_p_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_VsyncStatus( parse_t *pars_p, char *result_sym_p )
{
    U32 MTop, MBot;
    U32 ATop, ABot;
    U32 MTopL, MBotL;
    U32 ATopL, ABotL;
    BOOL Reset;
    BOOL RetErr;

    RetErr = FALSE;

    RetErr = STTST_GetInteger( pars_p, FALSE, (S32 *)&Reset );

    VTG_WAITVSYNC_ProtectArray
    if (Reset == TRUE)
    {
        /* MAIN                                                                */
        MTop  = Vtg_WaitVsyncArray_Main.CountTop     = 0;
        MBot  = Vtg_WaitVsyncArray_Main.CountBottom  = 0;

        MTopL = Vtg_WaitVsyncArray_Main.CountTopLock    = 0;
        MBotL = Vtg_WaitVsyncArray_Main.CountBottomLock = 0;

        /* AUX                                                                 */
        ATop  = Vtg_WaitVsyncArray_Aux.CountTop      = 0;
        ABot  = Vtg_WaitVsyncArray_Aux.CountBottom   = 0;
        ATopL = Vtg_WaitVsyncArray_Aux.CountTopLock    = 0;
        ABotL = Vtg_WaitVsyncArray_Aux.CountBottomLock = 0;
    }
    else
    {
        MTop  = Vtg_WaitVsyncArray_Main.CountTop;
        MBot  = Vtg_WaitVsyncArray_Main.CountBottom;
        MTopL = Vtg_WaitVsyncArray_Main.CountTopLock;
        MBotL = Vtg_WaitVsyncArray_Main.CountBottomLock;

        ATop  = Vtg_WaitVsyncArray_Aux.CountTop;
        ABot  = Vtg_WaitVsyncArray_Aux.CountBottom;
        ATopL = Vtg_WaitVsyncArray_Aux.CountTopLock;
        ABotL = Vtg_WaitVsyncArray_Aux.CountBottomLock;
    }
    VTG_WAITVSYNC_UnProtectArray

    STTBX_Report((STTBX_REPORT_LEVEL_INFO, "Vsync Status Count, Vsync occurs/Wait taken"));
    STTBX_Report((STTBX_REPORT_LEVEL_INFO, "Main\tTop % 8u / % 8u Bottom % 8u / % 8u ",
                  MTop, MTopL, MBot, MBotL));
    STTBX_Report((STTBX_REPORT_LEVEL_INFO, "Aux \tTop % 8u / % 8u Bottom % 8u / % 8u ",
                  ATop, ATopL, ABot, ABotL));

    STTBX_Report((STTBX_REPORT_LEVEL_INFO,"Wait 5 seconds"));
    task_delay(ST_GetClocksPerSecond()*5); /* Wait 5 seconds */

    VTG_WAITVSYNC_ProtectArray
    MTop  = Vtg_WaitVsyncArray_Main.CountTop - MTop;
    MBot  = Vtg_WaitVsyncArray_Main.CountBottom - MBot;
    MTopL = Vtg_WaitVsyncArray_Main.CountTopLock - MTopL;
    MBotL = Vtg_WaitVsyncArray_Main.CountBottomLock - MBotL;

    ATop  = Vtg_WaitVsyncArray_Aux.CountTop - ATop;
    ABot  = Vtg_WaitVsyncArray_Aux.CountBottom - ABot;
    ATopL = Vtg_WaitVsyncArray_Aux.CountTopLock - ATopL;
    ABotL = Vtg_WaitVsyncArray_Aux.CountBottomLock - ABotL;
    VTG_WAITVSYNC_UnProtectArray

    STTBX_Report((STTBX_REPORT_LEVEL_INFO, "Main\tTop % 8u / % 8u Bottom % 8u / % 8u ",
                  MTop, MTopL, MBot, MBotL));
    STTBX_Report((STTBX_REPORT_LEVEL_INFO, "Aux \tTop % 8u / % 8u Bottom % 8u / % 8u ",
                  ATop, ATopL, ABot, ABotL));

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

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

} /* end TTVTG_VsyncStatus */
#endif /* (TTVTG_DEBUG == TRUE) */

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

    RetErr |= STTST_RegisterCommand("VTG_INIT",    TTVTG_Init,  INS_DEVICEID"<DefaultClock(0:HD,1:SD)>Init VTG");
    RetErr |= STTST_RegisterCommand("VTG_OPEN",    TTVTG_Open,  INS_DEVICEHANDLEID"Open VTG");
    RetErr |= STTST_RegisterCommand("VTG_CLOSE",   TTVTG_Close, INS_DEVICEHANDLEID"Close VTG");
    RetErr |= STTST_RegisterCommand("VTG_TERM",    TTVTG_Term,  INS_DEVICEHANDLEID"<Force> Term VTG");
    RetErr |= STTST_RegisterCommand("VTG_GETMODE", TTVTG_GetMode, INS_DEVICEHANDLEID"Get VTG Mode");
    RetErr |= STTST_RegisterCommand("VTG_SETMODE", TTVTG_SetMode, INS_DEVICEHANDLEID"<VTG_MODE> Set VTG Mode");
    RetErr |= STTST_RegisterCommand("VTG_SETSPARAM", TTVTG_SetSlaveModeParams, INS_DEVICEHANDLEID"<SLAVE MODE><H SRC><V SRC><BOTTOM DETECT MIN><BOTTOM DETECT MAX><EXT VSYNC SHAPE><EXT VSYNC RISING EDGE><H VSYNC RISING EDGE> Set VTG Slave Mode Parameters");
    RetErr |= STTST_RegisterCommand("VTG_GETREV",  TTVTG_GetRevision, INS_DEVICEHANDLEID"Get Revision");
    RetErr |= STTST_RegisterCommand("VTG_GETOPTION", TTVTG_GetOptionalConfiguration, INS_DEVICEHANDLEID"Get Option");
    RetErr |= STTST_RegisterCommand("VTG_SETOPTION", TTVTG_SetOptionalConfiguration, INS_DEVICEHANDLEID"<EmbSync><NoOutSign> Set Option");

#if (TTVTG_DEBUG == TRUE)
    RetErr |= STTST_RegisterCommand("VTG_VSYNCSTATUS", TTVTG_VsyncStatus, "<Reset ?>Display Vsyndc status");
#endif /* (TTVTG_DEBUG == TRUE) */

    RetErr |= STTST_AssignInteger("VTGSM_H_AND_V",STVTG_SLAVE_MODE_H_AND_V, TRUE);
    RetErr |= STTST_AssignInteger("VTGSM_H",STVTG_SLAVE_MODE_H_ONLY, TRUE);
    RetErr |= STTST_AssignInteger("VTGSM_V",STVTG_SLAVE_MODE_V_ONLY, TRUE);

    RetErr |= STTST_AssignInteger("VTGSOF_PIN",STVTG_SLAVE_OF_PIN, TRUE);
    RetErr |= STTST_AssignInteger("VTGSOF_REF",STVTG_SLAVE_OF_REF, TRUE);
    RetErr |= STTST_AssignInteger("VTGSOF_SDIN1",STVTG_SLAVE_OF_SDIN1, TRUE);
    RetErr |= STTST_AssignInteger("VTGSOF_SDIN2",STVTG_SLAVE_OF_SDIN2, TRUE);
    RetErr |= STTST_AssignInteger("VTGSOF_HDIN",STVTG_SLAVE_OF_HDIN, TRUE);

    RetErr |= STTST_AssignInteger("VTGEXTVSHAPE_BNOTT",STVTG_EXT_VSYNC_SHAPE_BNOTT, TRUE);
    RetErr |= STTST_AssignInteger("VTGEXTVSHAPE_PULSE",STVTG_EXT_VSYNC_SHAPE_PULSE, TRUE);

    RetErr |= STTST_AssignInteger("VTGOPT_EMBSYNC",    STVTG_OPTION_EMBEDDED_SYNCHRO,  TRUE);
    RetErr |= STTST_AssignInteger("VTGOPT_NOOUTSIG",   STVTG_OPTION_NO_OUTPUT_SIGNAL,  TRUE);
    RetErr |= STTST_AssignInteger("VTGOPT_HSYNCPOL",   STVTG_OPTION_HSYNC_POLARITY,    TRUE);
    RetErr |= STTST_AssignInteger("VTGOPT_VSYNCPOL",   STVTG_OPTION_VSYNC_POLARITY,    TRUE);
    RetErr |= STTST_AssignInteger("VTGOPT_OUTEDGEPOS", STVTG_OPTION_OUT_EDGE_POSITION, TRUE);

    /* Give name to each enum                                                  */
    for ( loop=0 ; loop < VTG_MAX_MODE ; loop ++ )
    {
        /* Cast to char, VTG_ModeName is a cont                                */
        RetErr |= STTST_AssignInteger((char *)(VTG_ModeName[loop].Name),
                                      VTG_ModeName[loop].Num, TRUE);
    }

    /* Assign DeviceId to string                                               */
    for ( loop = 0 ; loop < VTG_MAXDEVICE ; loop++ )
    {
        RetErr |= STTST_AssignInteger(VTG_GET_DEVICENAME(loop), loop, FALSE);
    }

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

    return( RetErr );

} /* end VTG_InitCommand */

#endif /* TESTTOOL */

/* EOF */