vtg.c

ST5100 driver files for ST chipset

        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STVTG_GetOptionalConfiguration()=%s",
                      GetErrorText(ErrCode)));
    }
    else
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STVTG_GetOptionalConfiguration()=%s",
                      GetErrorText(ErrCode)));
    }

    return ( KeepErrCode );

} /* end VTG_GetOptionalConfiguration */


/*-------------------------------------------------------------------------------
 * Function : VTG_Init
 *            initialise VTG
 * Input    : VTG DeviceId, CLKRV DeviceId
 * Output   :
 * Return   : Error Code
 * --------------------------------------------------------------------------- */
ST_ErrorCode_t VTG_Init( VTG_DeviceId_t DeviceId )
{
    ST_ErrorCode_t          ErrCode;
    STVTG_InitParams_t      InitParams;
    U32                     i;

    /* Wait VSYNC                                                              */
    VTG_WaitVsync_t        *Array_p; /* Choose the good array                  */

    /* STEVT                                                                   */
    STEVT_OpenParams_t            EvtOpenP;                           /* Dummy */
    STEVT_DeviceSubscribeParams_t EvtDeviceSubscribeParams;

    ErrCode = ST_NO_ERROR;
	memset((void *)&InitParams, 0, sizeof(STVTG_InitParams_t));

    InitParams.DeviceType                          = VTG_GET_DEVICETYPE(DeviceId);
    InitParams.MaxOpen                             = VTG_MAXOPEN;
    InitParams.Target.VtgCell3.BaseAddress_p       = (void *)VTG_GET_BASEADDRESS(DeviceId);
    InitParams.Target.VtgCell3.DeviceBaseAddress_p = (void *)VTG_GET_DEVBASEADDRESS(DeviceId);
    InitParams.Target.VtgCell3.InterruptNumber     = VTG_GET_INTNUMBER(DeviceId);
    InitParams.Target.VtgCell3.InterruptLevel      = VTG_GET_INTLEVEL(DeviceId);

	strcpy( InitParams.Target.VtgCell3.ClkrvName, VTG_GET_CLKRVDEVICENAME(DeviceId) );
    strcpy( InitParams.EvtHandlerName, EVT_GET_DEVICENAME(VTG_GET_EVTDEVICEID(DeviceId)) );

    /* Init VTG */
    ErrCode = STVTG_Init(VTG_GET_DEVICENAME(DeviceId), &InitParams);
    if ( ErrCode == ST_NO_ERROR )
    {
        /* Initialize Handle if no error                             */
        for ( i = 0 ; i < VTG_MAXOPEN; i++ )
        {
            VTG_GET_HANDLE(DeviceId,i)   = VTG_HANDLE_NULL;
        }
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STVTG_Init(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));
    }
    else
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STVTG_Init(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));

    }

    /* Choose the good array to access                                         */
    if (ErrCode == ST_NO_ERROR)
    {
        ErrCode = vtg_WaitVsyncGetArray(DeviceId, &Array_p);
        /* If error, STTBX as already been called                              */
    }

    /* Initialize semaphore VSYNC                                              */
    if (ErrCode == ST_NO_ERROR)
    {
		Array_p = Array_p; /*lint*/
        semaphore_init_fifo_timeout(VTG_GETSEMTOP(Array_p), 0);
        semaphore_init_fifo_timeout(VTG_GETSEMBOT(Array_p), 0);

        memset((void *)&EvtOpenP, 0, sizeof(STEVT_OpenParams_t));
        ErrCode = STEVT_Open(EVT_GET_DEVICENAME(VTG_GET_EVTDEVICEID(DeviceId)),
                             &EvtOpenP, &VTG_GET_EVTHANDLE(DeviceId));
        if (ErrCode != ST_NO_ERROR)
        {
            STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STEVT_Open()=%s",
                          GetErrorText(ErrCode)));
        }

    	/* Subscribe to Event STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT                */
        EvtDeviceSubscribeParams.NotifyCallback     = VTG_WaitVsyncCallback;
        /* Pass to the call back the array linked to the DeviceName            */
        EvtDeviceSubscribeParams.SubscriberData_p   = Array_p;
        ErrCode = STEVT_SubscribeDeviceEvent(VTG_GET_EVTHANDLE(DeviceId),
                                             VTG_GET_DEVICENAME(DeviceId),
                                             STVTG_VSYNC_EVT,
                                             &EvtDeviceSubscribeParams);
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STEVT_Subscribe()=%s",
                      GetErrorText(ErrCode)));
	}
    /* Unsubscribe and close will be done when we Term the VTG                */
    /* Event Handle is stored into app_data                                   */

    return ( ErrCode );

} /* end VTG_Init */

/*-------------------------------------------------------------------------------
 * Function : VTG_Open
 *            open VTG
 * Input    : DeviceId, HandleId
 * Output   :
 * Return   : Error Code
 * --------------------------------------------------------------------------- */
ST_ErrorCode_t VTG_Open( VTG_DeviceId_t DeviceId, VTG_HandleId_t HandleId )
{
    ST_ErrorCode_t          ErrCode;
    STVTG_OpenParams_t      OpenParams;                        /* no parms yet */
    STTBX_ReportLevel_t     ReportLevel;

    ErrCode     = ST_NO_ERROR;
    ReportLevel = STTBX_REPORT_LEVEL_INFO;

    if (HandleId >= VTG_MAXOPEN)
    {
        ErrCode = ST_ERROR_BAD_PARAMETER;
    }
    if ( VTG_GET_HANDLE(DeviceId,HandleId) != VTG_HANDLE_NULL )
    {
        ErrCode = ST_ERROR_BAD_PARAMETER;
    }

    if (ErrCode == ST_NO_ERROR)
    {
        memset((void *) &OpenParams, 0, sizeof(STVTG_OpenParams_t));
        ErrCode = STVTG_Open(VTG_GET_DEVICENAME(DeviceId), &OpenParams,
                             &VTG_GET_HANDLE(DeviceId, HandleId));
        if (ErrCode != ST_NO_ERROR)
        {
            ReportLevel = STTBX_REPORT_LEVEL_ERROR;
        }
    }

    STTBX_Report((ReportLevel, "STVTG_Open(%s)=%s", VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));

    return ( ErrCode );

} /* end VTG_Open */

/*-------------------------------------------------------------------------------
 * Function : VTG_SetMode
 *            Set VTG Mode
 * Input    : DeviceId, HandleId, Timing Mode
 * Output   :
 * Return   : Error Code
 * --------------------------------------------------------------------------- */
ST_ErrorCode_t VTG_SetMode( VTG_DeviceId_t DeviceId, VTG_HandleId_t HandleId, STVTG_TimingMode_t TimingMode )
{
    ST_ErrorCode_t          ErrCode;
    U32                     loop;

    ErrCode = STVTG_SetMode( VTG_GET_HANDLE(DeviceId, HandleId), TimingMode );

    if (ErrCode == ST_NO_ERROR)
    {
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STVTG_SetMode(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));
    }
    else
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STVTG_SetMode(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));
    }
#if 0 // EXT_SHARE 	

    if (ErrCode == ST_NO_ERROR)
    {
        for(loop=0; loop<VTG_MAX_MODE; loop ++)
        {
            if (TimingMode == VTG_ModeName[loop].Num)
            {
                STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STVTG Set : %s",
                              VTG_ModeName[loop].Name));
                break;
            }
        }
    }
#endif
    return (ErrCode);

} /* end VTG_SetMode */

/*-------------------------------------------------------------------------------
 * Function : VTG_SetSlaveModeParams
 *            Set VTG Slave Mode Parameters
 * Input    : DeviceId, HandleId, SlaveModeParams_p
 * Output   :
 * Return   : Error Code
 * --------------------------------------------------------------------------- */
ST_ErrorCode_t VTG_SetSlaveModeParams( VTG_DeviceId_t DeviceId, VTG_HandleId_t HandleId,
                                       STVTG_SlaveModeParams_t *SlaveModeParams_p )
{
    ST_ErrorCode_t          ErrCode;

    ErrCode = STVTG_SetSlaveModeParams( VTG_GET_HANDLE(DeviceId, HandleId), SlaveModeParams_p );

    if ( ErrCode == ST_NO_ERROR )
    {
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STVTG_SetSlaveModeParams(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));
    }
    else
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STVTG_SetSlaveModeParams(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));
    }

    return ( ErrCode );

} /* end VTG_SetSlaveModeParams */

/*-------------------------------------------------------------------------------
 * Function : VTG_SetOptionalConfiguration
 *            Set VTG Optional Configuration
 * Input    : DeviceId, HandleId, Timing Mode
 * Output   :
 * Return   : Error Code
 * --------------------------------------------------------------------------- */
ST_ErrorCode_t VTG_SetOptionalConfiguration( VTG_DeviceId_t DeviceId, VTG_HandleId_t HandleId,
                                             STVTG_OptionalConfiguration_t *VTGOption )
{
    ST_ErrorCode_t          ErrCode;

    ErrCode = STVTG_SetOptionalConfiguration( VTG_GET_HANDLE(DeviceId, HandleId), VTGOption );

    if (ErrCode == ST_NO_ERROR)
    {
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STVTG_SetOptionalConfiguration(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));
    }
    else
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STVTG_SetOptionalConfiguration(%s)=%s",
                      VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));
    }

    return (ErrCode);

} /* end VTG_SetOptionalConfiguration */


/*-------------------------------------------------------------------------------
 * Function : VTG_Term
 *            terminate VTG
 * Input    : DeviceId, ForceTerminate
 * Output   :
 * Return   : Error Code
 * --------------------------------------------------------------------------- */
ST_ErrorCode_t VTG_Term( VTG_DeviceId_t DeviceId, BOOL ForceTerminate )
{
    ST_ErrorCode_t          ErrCode;
    STVTG_TermParams_t      TermParams;
    STTBX_ReportLevel_t     ReportLevel;
    /* Wait VSYNC                                                              */
    VTG_WaitVsync_t        *Array_p; /* Choose the good array                  */

    TermParams.ForceTerminate = ForceTerminate;

    ErrCode = STVTG_Term(VTG_GET_DEVICENAME(DeviceId), &TermParams);

    /* UnSubscribe to Event STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT               */
    if ( (ErrCode == ST_NO_ERROR) || (ForceTerminate == TRUE) )
    {
        ErrCode = STEVT_UnsubscribeDeviceEvent(VTG_GET_EVTHANDLE(DeviceId),
                                               VTG_GET_DEVICENAME(DeviceId),
                                               STVTG_VSYNC_EVT);
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STEVT_UnSubscribe()=%s",
                      GetErrorText(ErrCode)));
    }

    /* Close Event                                                              */
    if ( (ErrCode == ST_NO_ERROR) || (ForceTerminate == TRUE) )
    {
        ErrCode = STEVT_Close(VTG_GET_EVTHANDLE(DeviceId));
        if (ErrCode != ST_NO_ERROR)
        {
            STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STEVT_Close()=%s",
                          GetErrorText(ErrCode)));
        }
    }

    /* Choose the good array to access                                         */
    if (ErrCode == ST_NO_ERROR)
    {
        ErrCode = vtg_WaitVsyncGetArray(DeviceId, &Array_p);
        /* If error, STTBX as already been called                              */

        semaphore_delete(VTG_GETSEMTOP(Array_p));
        semaphore_delete(VTG_GETSEMBOT(Array_p));
    }

    if ( ErrCode == ST_NO_ERROR )
    {
        ReportLevel = STTBX_REPORT_LEVEL_INFO;
    }
    else
    {
        ReportLevel = STTBX_REPORT_LEVEL_ERROR;
    }

    STTBX_Report((ReportLevel, "STVTG_Term(%s)=%s", VTG_GET_DEVICENAME(DeviceId), GetErrorText(ErrCode)));

    return ( ErrCode );

} /* end VTG_Term */


/*********************************************************************************/
/*                               WaitVSYNC                                       */
/*********************************************************************************/
/* Need to wait for a VSYNC is very high in STAPIDemo. A simple system           */
/* is implemented here.                                                          */
/*                                                                               */
/* Timeout semaphore are used to be able to test the counter.                    */
/*********************************************************************************/

/*-------------------------------------------------------------------------------
 * Function : VTG_WaitVsync
 *            Wait for a VSYNC, Top or Bottom on choosen VTG Device
 * Input    : VTG_DeviceId_t VTGDeviceId, STVTG_VSYNC_t VsyncType
 * Output   : N/A
 * Return   : Error Code
 * --------------------------------------------------------------------------- */
ST_ErrorCode_t VTG_WaitVsync(VTG_DeviceId_t VTGDeviceId, STVTG_VSYNC_t VsyncType )
{
    ST_ErrorCode_t ErrCode;
    VTG_WaitVsync_t *Array_p;        /* Point to the Array for VTG_MAIN or AUX */

    ErrCode = ST_NO_ERROR;

    /* Choose the good array to access                                         */
    if (ErrCode == ST_NO_ERROR)