main.c

ST5100 driver files for ST chipset

int SetRefPath( void )
{
    if (strlen(DVD_REF) >= 255)
    {
        fprintf(stderr,"DVD_REF is too long. No more than 255 char\n");
		return (1);
    }
    else
    {
        strcpy(STDM_ReferencePath, DVD_REF);
    }

	return (0);
}

#if defined(TESTTOOL)
/*------------------------------------------------------------------------------
 * Function : TST_Init
 *            Init Testtool
 * Input    : N/A
 * Output   : N/A
 * Return   : Error Code
 * -------------------------------------------------------------------------- */
static ST_ErrorCode_t TST_Init(void)
{
    STTST_InitParams_t InitParams;
    ST_ErrorCode_t     ErrCode;

    ErrCode = ST_NO_ERROR;
    memset(InitParams.InputFileName, 0, sizeof(InitParams.InputFileName));

    InitParams.CPUPartition_p = SystemPartition;
    InitParams.NbMaxOfSymbols = 2000;
    strcpy(InitParams.InputFileName, "../../../shared/default.com");
    if (InitParams.CPUPartition_p == NULL)
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR,
                      "Memory partition undefined, Testtool cannot be started !!"));
        ErrCode = ST_ERROR_NO_MEMORY;
    }
    else
    {
        if (STTST_Init(&InitParams) == TRUE)
        {
            STTBX_Report((STTBX_REPORT_LEVEL_ERROR,
                          "STTST_Init() fails !"));
            ErrCode = ST_ERROR_BAD_PARAMETER;
        }
    }

    return ErrCode;
} /* TST_Init () */

/*------------------------------------------------------------------------------
 * Function : Start_Testtool
 *            Register testtool command and start
 *            Testtool
 * Input    : N/A
 * Output   : N/A
 * Return   : Error Code
 * -------------------------------------------------------------------------- */
static ST_ErrorCode_t Start_Testtool(void)
{
    BOOL RetErr;

    RetErr = FALSE;

    RetErr |= STTST_SetMode(STTST_NO_ABBREVIATION_MODE);

    /* init Testtool commands */
    RetErr |= API_InitCommand();
    RetErr |= AUD_InitCommand();
    RetErr |= BLIT_InitCommand();
    RetErr |= DENC_InitCommand();
	RetErr |= GENERIC_InitCommand();
    RetErr |= GXOBJ_InitCommand();
    RetErr |= VTG_InitCommand();
    RetErr |= VOUT_InitCommand();
    RetErr |= LAYER_InitCommand();
    RetErr |= VMIX_InitCommand();
    RetErr |= VID_InitCommand();
    RetErr |= CLKRV_InitCommand();
    RetErr |= DISP_InitCommand();
    RetErr |= I2C_InitCommand();
	RetErr |= PTI_InitCommand();
	RetErr |= TSMERGE_InitCommand();
	RetErr |= GUTIL_InitCommand();
    RetErr |= VIN_InitCommand();
#ifndef TESTAPP_DISABLE_HDMI
    RetErr |= HDMI_InitCommand();
#endif /* #ifndef TESTAPP_DISABLE_HDMI */
	RetErr |= VBI_InitCommand();
    
#if defined(ST_PSIP)
    RetErr |= Register_ZPSIPCommands();
#endif

	/*RetErr |= TTOS_RegisterCommand();*/

    /* Start Testtool                                                         */
    RetErr = TSTREG_Debug();

    if (RetErr == TRUE)
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR,
                      "\n TSTREG_Debug, an error occurs in init of DEBUG/REG READ/REG WRITE \n"));
        return ST_ERROR_BAD_PARAMETER;
    }
    else
        STTBX_Print(("\n TSTREG_Debug was successfully initialised... \n"));

	TSTREG_AddRegArray(CKG_Reg, CKG_REGISTERS);
	TSTREG_AddRegArray(AudioReg, AUDIO_REGISTERS);
	TSTREG_AddRegArray(DVP_Reg, DVP_REGISTERS);
	TSTREG_AddRegArray(GammaReg, GAMMA_REGISTERS);
	TSTREG_AddRegArray(HdcpReg, HDCP_REGISTERS);
	/*TSTREG_AddRegArray(HDDI_Reg, HDDI_REGISTERS);	*/
	TSTREG_AddRegArray(HdmiReg, HDMI_REGISTERS);
/*	TSTREG_AddRegArray(I2C_Reg, I2C_REGISTERS);	*/
	TSTREG_AddRegArray(IRB_Reg, IRB_REGISTERS);
	TSTREG_AddRegArray(LPM_Reg, LPM_REGISTERS);
	TSTREG_AddRegArray(MAF_Reg, MAF_REGISTERS);
	TSTREG_AddRegArray(PIO_Reg, PIO_REGISTERS);
	TSTREG_AddRegArray(PWM_Reg, PWM_REGISTERS);
	/*TSTREG_AddRegArray(SdinReg, SDIN_REGISTERS);	*/
	TSTREG_AddRegArray(SMART_Reg, SMART_REGISTERS);
	TSTREG_AddRegArray(UART_Reg, UART_REGISTERS);
	TSTREG_AddRegArray(VideoReg, VIDEO_REGISTERS);
	TSTREG_AddRegArray(VOS_Reg, VOS_REGISTERS);

    RetErr |= STTST_Start();
    if (RetErr == TRUE)
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR,
                      "TESTTOOL, an error occurs in init"));
        return ST_ERROR_BAD_PARAMETER;
    }
    else
    {
        return ST_NO_ERROR;
    }

} /* Start_Testtool () */
#endif /* ifdef TESTTOOL */


/*----------------------------------------------------------------------------
 * Function : GetStapiRevisions
 *            Display versions of stapi drivers
 * Input    :
 * Output   :
 * Return   :
 * -------------------------------------------------------------------------- */
void GetStapiRevisions(void)
{
#if 0 // EXT_SHARE
    STTBX_Print(("STAUD_GetRevision()   = %s\n", STAUD_GetRevision()));
	STTBX_Print(("STAVMEM_GetRevision() = %s\n", STAVMEM_GetRevision()));
	STTBX_Print(("STBLAST_GetRevision() = %s\n", STBLAST_GetRevision()));
	STTBX_Print(("STBLIT_GetRevision()  = %s\n", STBLIT_GetRevision()));
	STTBX_Print(("STBOOT_GetRevision()  = %s\n", STBOOT_GetRevision()));
    STTBX_Print(("STCC_GetRevision()    = %s\n", STCC_GetRevision()));
	STTBX_Print(("STCLKRV_GetRevision() = %s\n", STCLKRV_GetRevision()));
	STTBX_Print(("STDENC_GetRevision()  = %s\n", STDENC_GetRevision()));
	STTBX_Print(("STEVT_GetRevision()   = %s\n", STEVT_GetRevision()));
	STTBX_Print(("STFDMA_GetRevision()  = %s\n", STFDMA_GetRevision()));
	STTBX_Print(("STFLASH_GetRevision() = %s\n", STFLASH_GetRevision()));
	STTBX_Print(("STGXOBJ_GetRevision() = %s\n", STGXOBJ_GetRevision()));
#ifndef TESTAPP_DISABLE_HDMI
    STTBX_Print(("STHDMI_GetRevision()  = %s\n", STHDMI_GetRevision()));
#endif
	STTBX_Print(("STI2C_GetRevision()   = %s\n", STI2C_GetRevision()));
	STTBX_Print(("STLAYER_GetRevision() = %s\n", STLAYER_GetRevision()));
	STTBX_Print(("STMERGE_GetRevision() = %s\n", STMERGE_GetRevision()));
	STTBX_Print(("STOS_GetRevision()    = %s\n", STOS_GetRevision()));
	STTBX_Print(("STPIO_GetRevision()   = %s\n", STPIO_GetRevision()));
	STTBX_Print(("STPTI_GetRevision()   = %s\n", STPTI_GetRevision()));
	STTBX_Print(("STTBX_GetRevision()   = %s\n", STTBX_GetRevision()));
	STTBX_Print(("STTST_GetRevision()   = %s\n", STTST_GetRevision()));
	STTBX_Print(("STTTX_GetRevision()   = %s\n", STTTX_GetRevision()));	
	STTBX_Print(("STTUNER_GetRevision() = %s\n", STTUNER_GetRevision()));
	STTBX_Print(("STUART_GetRevision()  = %s\n", STUART_GetRevision()));
	STTBX_Print(("STVBI_GetRevision()   = %s\n", STVBI_GetRevision()));
	STTBX_Print(("STVID_GetRevision()   = %s\n", STVID_GetRevision()));
	STTBX_Print(("STVIN_GetRevision()   = %s\n", STVIN_GetRevision()));
	STTBX_Print(("STVMIX_GetRevision()  = %s\n", STVMIX_GetRevision()));
	STTBX_Print(("STVOUT_GetRevision()  = %s\n", STVOUT_GetRevision()));
	STTBX_Print(("STVTG_GetRevision()   = %s\n", STVTG_GetRevision()));

	STTBX_Print(("\n"));
#endif	
}

#if 0 // EXT_SHARE
/*------------------------------------------------------------------------------
 * Function : Statapi_Test
 *            Test STATAPI driver basic API
 * Input    : N/A
 * Output   : N/A
 * Return   : Error Code
 * -------------------------------------------------------------------------- */
ST_ErrorCode_t Statapi_Test(void)
{
    /* Parameters, buffers, and structures */
    ST_ErrorCode_t ST_ErrorCode;
    STATAPI_InitParams_t    InitParams;
    STATAPI_Handle_t        Handle;
    STATAPI_OpenParams_t    OpenParams;
    STATAPI_TermParams_t 	TermParams;
	ST_DeviceName_t         AtapiDevName = "ATAPI_0";
	U32 temp;
	
	ClockFrequency = ST_ClockInfo.HDDI;
	if (ClockFrequency == 0)
		ClockFrequency = ST_ClockInfo.CommsBlock;

    InitParams.DeviceType           = STATAPI_EMI_PIO4;
    InitParams.DriverPartition      = SystemPartition;
    InitParams.BaseAddress          = (volatile U32 *)0x43000000;
    InitParams.HW_ResetAddress      = (volatile U16 *)0x43000000;
    InitParams.InterruptNumber      = EXTERNAL_3_INTERRUPT;
    InitParams.InterruptLevel       = ATA_INTERRUPT_LEVEL; /* 6 */
    InitParams.ClockFrequency       = ClockFrequency;

    strcpy(InitParams.EVTDeviceName, "EVT_BACK");
	
    temp = STSYS_ReadRegDev32LE(0x41a00000); /* keep original value to write back */
	STSYS_WriteRegDev32LE(0x41a00000, 0x01010101);

    ST_ErrorCode = STATAPI_Init(AtapiDevName, &InitParams);
    if (ST_ErrorCode != ST_NO_ERROR)
    {   
		if (ST_ErrorCode == STATAPI_ERROR_DEVICE_NOT_PRESENT) {
	        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STATAPI_Init()=%s",
	                      "STATAPI_ERROR_DEVICE_NOT_PRESENT "));
		}
		else {
	        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STATAPI_Init()=%s",
	                      GetErrorText(ST_ErrorCode)));
		}
    }
	else
	{         
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STATAPI_Init()=OK",
                      GetErrorText(ST_ErrorCode)));
    }

    OpenParams.DeviceAddress = STATAPI_DEVICE_0;
	if (ST_ErrorCode == ST_NO_ERROR)
	{
	    ST_ErrorCode = STATAPI_Open(AtapiDevName, &OpenParams, &Handle);
	    if (ST_ErrorCode != ST_NO_ERROR)
	    {         
	        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STATAPI_Open()=%s",
	                      GetErrorText(ST_ErrorCode)));
	    }
		else
		{         
	        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STATAPI_Open()=OK",
	                      GetErrorText(ST_ErrorCode)));
	    }
	}

	if (ST_ErrorCode == ST_NO_ERROR)
	{
	    ST_ErrorCode = STATAPI_Close(Handle);
	    if (ST_ErrorCode != ST_NO_ERROR)
	    {         
	        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STATAPI_Close()=%s",
	                      GetErrorText(ST_ErrorCode)));
	    }
		else
		{         
	        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STATAPI_Close()=OK",
	                      GetErrorText(ST_ErrorCode)));
	    }
	}

	if (ST_ErrorCode == ST_NO_ERROR)
	{
	    TermParams.ForceTerminate = TRUE;
	    ST_ErrorCode = STATAPI_Term(AtapiDevName, &TermParams);
	    if (ST_ErrorCode != ST_NO_ERROR)
	    {         
	        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STATAPI_Term()=%s",
	                      GetErrorText(ST_ErrorCode)));
	    }
		else
		{         
	        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STATAPI_Term()=OK",
	                      GetErrorText(ST_ErrorCode)));
	    }
	}

	STSYS_WriteRegDev32LE(0x41a00000, temp);

    return ST_ErrorCode;
} /* Statapi_Test () */


/*------------------------------------------------------------------------------
 * Function : Stpccrd_Test
 *            Test STPCCRD driver basic API
 * Input    : N/A
 * Output   : N/A
 * Return   : Error Code
 * -------------------------------------------------------------------------- */
ST_ErrorCode_t Stpccrd_Test(void)
{
    /* Parameters, buffers, and structures */
    ST_ErrorCode_t          ST_ErrorCode;
	STPCCRD_InitParams_t	PCCRD_InitParams;
    STPCCRD_OpenParams_t    OpenParams;
    STPCCRD_Handle_t        Handle;
    STPCCRD_TermParams_t 	TermParams;
    PCCRD_InitParams.DeviceCode = 0x41900000;
    PCCRD_InitParams.MaxHandle  = 2;
    PCCRD_InitParams.DriverPartition_p = SystemPartition;

    ST_ErrorCode = STPCCRD_Init("STPCCRD_0",&PCCRD_InitParams);
    if (ST_ErrorCode != ST_NO_ERROR)
    {
        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STPCCRD_Init(%s)=%s",
                      "STPCCRD_Init", GetErrorText(ST_ErrorCode)));
    }
	else
	{         
        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STPCCRD_Init()=OK",
                      GetErrorText(ST_ErrorCode)));
    }
    
	if (ST_ErrorCode == ST_NO_ERROR)
	{
	    OpenParams.ModName = STPCCRD_MOD_A;
	    ST_ErrorCode = STPCCRD_Open("STPCCRD_0", &OpenParams, &Handle);
	    if (ST_ErrorCode != ST_NO_ERROR)
	    {
	        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STPCCRD_Open(%s)=%s",
	                      "STPCCRD_Open", GetErrorText(ST_ErrorCode)));
	    }
		else
		{         
	        STTBX_Report((STTBX_REPORT_LEVEL_INFO, "STPCCRD_Open(%s)=OK",
	                      "STPCCRD_MOD_A", GetErrorText(ST_ErrorCode)));
	    }
 	}
 	         
	if (ST_ErrorCode == ST_NO_ERROR)
	{
	    ST_ErrorCode = STPCCRD_Close(Handle);
	    if (ST_ErrorCode != ST_NO_ERROR)
	    {
	        STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STPCCRD_Close(%s)=%s",
	                      "STPCCRD_Close", GetErrorText(ST_ErrorCode)));
	    }