vtg.c

ST5100 driver files for ST chipset

    {
        ErrCode = vtg_WaitVsyncGetArray(VTGDeviceId, &Array_p);
        /* If error, STTBX as already been called                              */
    }

    if (ErrCode == ST_NO_ERROR)
    {
        switch (VsyncType)
        {
            case STVTG_TOP :
            {
#if (TTVTG_DEBUG == TRUE)
                VTG_WAITVSYNC_ProtectArray
                Array_p->CountTopLock ++;
                VTG_WAITVSYNC_UnProtectArray
#endif /* (TTVTG_DEBUG == TRUE) */
                semaphore_wait_timeout(VTG_GETSEMTOP(Array_p), TIMEOUT_INFINITY);
                break;
            }
            case STVTG_BOTTOM :
            {
#if (TTVTG_DEBUG == TRUE)
                VTG_WAITVSYNC_ProtectArray
                Array_p->CountBottomLock ++;
                VTG_WAITVSYNC_UnProtectArray
#endif /* (TTVTG_DEBUG == TRUE) */
                semaphore_wait_timeout(VTG_GETSEMBOT(Array_p), TIMEOUT_INFINITY);
                break;
            }
            default :
            {
                /* Will never pass here while Type is Top or Bottom            */
            }
        } /* switch (VsyncType) */
    }

    return ErrCode;

} /* VTG_WaitVsyncOnId () */


/*-------------------------------------------------------------------------------
 * Function : VTG_WaitVsyncCallback
 *            Callback function for VSYNC Wait function
 * Input    : STEVT_CallReason_t Reason,
 *            const ST_DeviceName_t RegistrantName,
 *            STEVT_EventConstant_t Event,
 *            const void *EventData
 *            const void *SubscriberData_p
 * Output   : N/A
 * Return   : N/A
 * --------------------------------------------------------------------------- */
static void VTG_WaitVsyncCallback (STEVT_CallReason_t Reason,
                            const ST_DeviceName_t RegistrantName,
                            STEVT_EventConstant_t Event,
                            const void *EventData,
                            const void *SubscriberData_p)
{
    VTG_WaitVsync_t *Array_p;
    STVTG_VSYNC_t    VsyncType;
    semaphore_t     *Sem_p;

    Array_p = ( VTG_WaitVsync_t *)SubscriberData_p;
    VsyncType = *((STVTG_VSYNC_t *)EventData);

	Sem_p = VTG_GETSEMTOP(Array_p);
    /* Get the good Semaphore                                                  */
    switch (VsyncType)
    {
        case STVTG_TOP :
        {
#if (TTVTG_DEBUG == TRUE)
            /* Count the number of VSYNC_TOP                                   */
            VTG_WAITVSYNC_ProtectArray
            (Array_p->CountTop) ++;
            VTG_WAITVSYNC_UnProtectArray
#endif /* (TTVTG_DEBUG == TRUE ) */
            Sem_p = VTG_GETSEMTOP(Array_p);
            break;
        }
        case STVTG_BOTTOM :
        {
#if (TTVTG_DEBUG == TRUE)
            /* Count the number of VSYNC_BOTTOM                                */
            VTG_WAITVSYNC_ProtectArray
            (Array_p->CountBottom) ++;
            VTG_WAITVSYNC_UnProtectArray
#endif /* (TTVTG_DEBUG == TRUE ) */
            Sem_p = VTG_GETSEMBOT(Array_p);
            break;
        }
        default :
        {
            /* Will never pass here while Type is Top or Bottom                */
        }
    } /* switch (VsyncType) */

    /* TIMEOUT_IMEDIATE will return imediately, two cases :                    */
    /* if sem is > 0 decrement it and return 0.                                */
    /* Else return -1, somebody is waiting on it, so signal it                 */

    /* Signal all task which are waiting on this semaphore                     */
    while (semaphore_wait_timeout(Sem_p,TIMEOUT_IMMEDIATE) == -1)
    {
        semaphore_signal(Sem_p);
    }

} /* VTG_WaitVsyncCallback () */

/*-------------------------------------------------------------------------------
 * Function : vtg_WaitVsyncGetArray
 *            Return the Array corresponding to the DeviceId
 * In/Out   : VTG_DeviceId_t VTGDeviceId
 * Return   : VTG_WaitVsync_t *Array_p, pointer to the good Array.
 * --------------------------------------------------------------------------- */
static ST_ErrorCode_t vtg_WaitVsyncGetArray(VTG_DeviceId_t DeviceId, VTG_WaitVsync_t **Array_p)
{
    ST_ErrorCode_t ErrCode;

    ErrCode = ST_NO_ERROR;

    switch(DeviceId)
    {
        case VTG_MAIN:
        {
            *Array_p = &Vtg_WaitVsyncArray_Main;
            break;
        }
        case VTG_AUX:
        {
            *Array_p = &Vtg_WaitVsyncArray_Aux;
            break;
        }
        default:
        {
            STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "Bad Device Id"));
            ErrCode = ST_ERROR_BAD_PARAMETER;
            *Array_p = NULL;
        }
    } /* switch(DeviceId) */

    return ErrCode;
} /* vtg_WaitVsyncGetArray () */

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

#ifdef TESTTOOL

#if (TTVTG_MULTI_INSTANCE == TRUE)
/*-------------------------------------------------------------------------------
 * Function : VtgGetParamDeviceId
 *            Get vtg DeviceId
 * Input    : pars_p
 * Output   : *DeviceId_p
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL VtgGetParamDeviceId( parse_t *pars_p, VTG_DeviceId_t *DeviceId_p )
{
        BOOL RetErr;

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

        return RetErr;
} /* VtgGetParamDeviceId() */

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

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

        return RetErr;
} /* VtgGetParamHandleId() */
#endif /* TTVTG_MULTI_INSTANCE */


/*-------------------------------------------------------------------------------
 * Function : TTVTG_Close
 *            close VTG
 * Input    : None
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_Close( 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_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 TTVTG_Close */

/*-------------------------------------------------------------------------------
 * Function : TTVTG_GetMode
 *            Get VTG Mode
 * Input    : *pars_p, *result_sym_p_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_GetMode( parse_t *pars_p, char *result_sym_p )
{
    ST_ErrorCode_t          ErrCode;
    STVTG_ModeParams_t      VTGModeParams;
    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_GetMode(DeviceId, HandleId, &VTGModeParams);
        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_GetMode */


/*-------------------------------------------------------------------------------
 * Function : TTVTG_GetOptionalConfiguration
 *            Get Optional Configuration
 * Input    : *pars_p, *result_sym_p_p
 * Output   :
 * Return   : TRUE if error, FALSE if success
 * --------------------------------------------------------------------------- */
static BOOL TTVTG_GetOptionalConfiguration( 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_GetOptionalConfiguration(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_GetOptionalConfiguration */

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