tfx4da.tmp

ST5100 driver files for ST chipset

/*****************************************************************************

File name  : tsmerge.c
Description: TSMERGE functions

COPYRIGHT (C) STMicroelectronics 2004.

*****************************************************************************/

/* Includes --------------------------------------------------------------- */

#include <string.h>
#include <stdio.h>

#include "errors.h"
#include "sections.h"   /* memory partitions */
#include "stcommon.h"
#include "stddefs.h"
#include "stlite.h"
#include "stdevice.h"
#include "sttbx.h"
#include "stsys.h"
#include "tsmerge.h"
#include "st_pti.h"
#ifdef TESTTOOL
 #include "testtool.h" 
 #include "api.h" 
#endif
/*#include "transport.h"*/
/*#include "common.h"*/

/* Private Types ------------------------------------------------------ */

/* Private Constants -------------------------------------------------- */
#define NUM_INSTANCE        0

#define SWTS_OUTPUT_STREAM_RATE (30000000)

/* Externals */
ST_ErrorCode_t SERVICE_TSMERGE_InitParams(TSIN_Used_t               TsinUsed,
                                          SERVICE_Mode_t            SERVICE_Mode,
                                          STMERGE_ObjectConfig_t  * STMERGE_ObjectConfig_p);

extern ST_ClockInfo_t ST_ClockInfo;

/* Private Variables -------------------------------------------------- */

/* Private Macros ----------------------------------------------------- */

/* Private Function prototypes ---------------------------------------- */
static char *TSmergeInput_ToStr(U32 TSInput);

/* Global Variables ------------------------------------------------------- */
ST_DeviceName_t TSMERGE_DeviceName = {"TSMERGE0"};
TSIN_Used_t     TSINUsed[] = {
                            #if !defined(TSIN1_NORMAL)
                                TSIN_0,
                            #else
                                TSIN_1,     /* can be replaced with TSIN_1, TSIN_2, SWTS_0 */
                            #endif
                            #if defined(DUAL_DVR)
                                TSIN_1,
                                SWTS_0,
                            #elif defined(PIP_SUPPORT) && !defined(SAME_TSIN)
                                TSIN_1,
                            #endif								
                                (TSIN_Used_t)0 };

/* Global Functions ------------------------------------------------------- */

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

/*-------------------------------------------------------------------------
 * Function : TSMERGE_Setup
 * Input    : None
 * Output   :
 * Return   : Error Code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t TSMERGE_Setup(TSIN_Used_t TsinUsed[], SERVICE_Mode_t SERVICE_Mode)
{
	STMERGE_InitParams_t		InitParams;
#ifndef TSMERGE_BYPASS
	STMERGE_ObjectConfig_t	Config;
	U8                      Index;
#endif
	ST_ErrorCode_t              ST_ErrorCode = ST_NO_ERROR;
	U32                         SimpleRAMMap[5][2] = { {(U32)TSIN_0,1024},
											{(U32)TSIN_1,1024},
											{(U32)TSIN_2,256},
											{(U32)SWTS_0,1024},
											{0,0}};
	/* Initialise STMERGE device */
	InitParams.DeviceType        = STMERGE_DEVICE_1;
	InitParams.BaseAddress_p     = (U32 *)TSMERGE_BASE_ADDRESS;
	InitParams.MergeMemoryMap_p  = SimpleRAMMap;
	InitParams.DriverPartition_p = DriverPartition;
	
#ifdef STMERGE_INTERRUPT_SUPPORT
	InitParams.InterruptNumber    = 55;
	InitParams.InterruptLevel     = 1;
#endif

#ifdef TSMERGE_BYPASS
	STTBX_Print(("\nTSMERGE_Setup(%s,%s)",TSMERGE_DeviceName,TSmergeInput_ToStr((U32)TsinUsed[0])));
	if ( (U32)TsinUsed[NUM_INSTANCE] == STMERGE_SWTS_0 )
	{
		InitParams.Mode			= STMERGE_BYPASS_SWTS0_TO_PTI0_ONLY;
	}
	else
	{
		InitParams.Mode			= STMERGE_BYPASS_TSIN0_TO_PTI0_ONLY;
	}
	STTBX_Print ((" Bypass mode :0x%x :",InitParams.Mode));
	ST_ErrorCode = STMERGE_Init(TSMERGE_DeviceName,&InitParams);
	if(ST_ErrorCode != ST_NO_ERROR)
	{
		STTBX_Print(("%s\n",GetErrorText(ST_ErrorCode)));
		return ST_ErrorCode;
	}
	STTBX_Print(("OK!\n"));

	/* swts config : Manual-Pace mode taken from STDVR test harness */
	//jky STSYS_WriteRegDev32LE(TSMERGE_BASE_ADDRESS+0x02e0, ((ST_ClockInfo.STBus / (SWTS_OUTPUT_STREAM_RATE / 8)) & 0xFFFF));

#else

	STTBX_Print(("\nTSMERGE_Setup(%s,%s)",TSMERGE_DeviceName,TSmergeInput_ToStr(TsinUsed[NUM_INSTANCE])));

	InitParams.Mode				= STMERGE_NORMAL_OPERATION_TO_PTI1;//jky 
	ST_ErrorCode = STMERGE_Init(TSMERGE_DeviceName, &InitParams);
	if(ST_ErrorCode != ST_NO_ERROR)
	{
		STTBX_Print(("%s\n",GetErrorText(ST_ErrorCode)));
		return ST_ErrorCode;
	}
	STTBX_Print(("%s\n", STMERGE_GetRevision() ));

	Config.Priority					 = STMERGE_PRIORITY_HIGHEST;
	Config.SOPSymbol				 = 0x47;

	for ( Index=0; TsinUsed[Index]!=0; Index++ )
	{
		ST_ErrorCode = SERVICE_TSMERGE_InitParams( TsinUsed[Index], SERVICE_Mode, &Config );
		if (ST_ErrorCode != ST_NO_ERROR)
		{
			return( ST_ErrorCode );
		}

		if ( TsinUsed[Index] == STMERGE_SWTS_0 )
		{
			Config.u.SWTS.Tagging       = STMERGE_TAG_ADD;
			/*    			Config.u.SWTS.Pace          = ((ST_ClockInfo.STBus / (SWTS_OUTPUT_STREAM_RATE / 8)) & 0xFFFF);*//*STMERGE_PACE_AUTO*/
			Config.u.SWTS.Pace          = STMERGE_PACE_AUTO;
			Config.u.SWTS.Counter.Value = STMERGE_COUNTER_AUTO_LOAD;
			Config.u.SWTS.Counter.Rate  = STMERGE_COUNTER_NO_INC;
			Config.u.SWTS.Trigger       = 10;
		}
		else
		{
			/* TSIN0 is set for serial input */
			if (TsinUsed[Index] == STMERGE_TSIN_0)	
			{
				//Config.u.TSIN.SerialNotParallel	 = TRUE;  
				//Config.u.TSIN.ByteAlignSOPSymbol = TRUE;  
				Config.u.TSIN.SerialNotParallel	 = FALSE;
				Config.u.TSIN.ByteAlignSOPSymbol = FALSE;
			} 
			else /* Others are set for parallel input */ 									
			{
				Config.u.TSIN.SerialNotParallel	 = FALSE;
				Config.u.TSIN.ByteAlignSOPSymbol = FALSE;
			}

			Config.u.TSIN.InvertByteClk		 = FALSE;
		}

		ST_ErrorCode = STMERGE_SetParams(TsinUsed[Index], &Config);
		if (ST_ErrorCode != ST_NO_ERROR)
		{
			STTBX_Print(("\n STMERGE_SetParams Failed!!! ST_ErrorCode = %s\n",GetErrorText(ST_ErrorCode) ));
		}
		ST_ErrorCode = STMERGE_Connect(TsinUsed[Index], STMERGE_PTI_1);
		if (ST_ErrorCode != ST_NO_ERROR)
		{
			STTBX_Print(("\n STMERGE_Connect Failed!!! ST_ErrorCode = %s\n",GetErrorText(ST_ErrorCode) ));
		}
	}
#endif

	return (ST_ErrorCode);
}

/*-------------------------------------------------------------------------
 * Function : TSmergeInput_ToStr
 * Input    : event data
 * Output   :
 * Return   : string
 * ----------------------------------------------------------------------*/
static char *TSmergeInput_ToStr(U32 TSInput)
{
    switch(TSInput)
    {
        case STMERGE_TSIN_0:
            return("STMERGE_TSIN_0");
        case STMERGE_TSIN_1:
            return("STMERGE_TSIN_1");
        case STMERGE_TSIN_2:
            return("STMERGE_TSIN_2");
        case STMERGE_SWTS_0:
            return("STMERGE_SWTS_0");
        default:
            break;
    }
    return("STMERGE?");
}


/*-------------------------------------------------------------------------
 * Function : TSMERGE_Term
 * Input    :
 * Output   :
 * Return   : ST_ERROR_BAD_PARAMETER if service not supported
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t TSMERGE_Term()
{
    ST_ErrorCode_t              ST_ErrorCode = ST_NO_ERROR;

    STTBX_Print(("TSMERGE_Term(%s)=", TSMERGE_DeviceName));

    ST_ErrorCode =  STMERGE_Term(TSMERGE_DeviceName, NULL);
    STTBX_Print(("%s\n", GetErrorText(ST_ErrorCode) ));

    return(ST_ErrorCode);
}

#ifdef TESTTOOL
/*------------------------------------------------------------------------------
 * Name        : TTMERGE_Setup
 * Description : Setup TSMERGE
 * Parameters  : *pars_p, *result_sym_p
 * Assumptions :
 * Limitations :
 * Returns     : TRUE if error, FALSE if success
 * -------------------------------------------------------------------------- */
static BOOL TTMERGE_Setup(parse_t *pars_p, char *result_sym_p)
{
    BOOL                    RetErr;
    ST_ErrorCode_t          ErrCode;
	SERVICE_Mode_t 	        SERVICE_Mode;
	S32						Lvar;

    RetErr   = FALSE;
    ErrCode  = ST_NO_ERROR;


	/* get the service mode */
    RetErr = STTST_GetInteger(pars_p, SERVICE_MODE_DVB, &Lvar);
    if (RetErr == TRUE)
    {
        STTST_TagCurrentLine(pars_p, "expected service mode: SERVICE_MODE_DVB | SERVICE_MODE_DTV");
    }
    SERVICE_Mode = (SERVICE_Mode_t)Lvar;

    /* call pti function */
    if (RetErr == FALSE)
    {
		ErrCode = TSMERGE_Setup(TSINUsed, SERVICE_Mode);
        if ( ErrCode != ST_NO_ERROR)
        {
            RetErr = TRUE;
        }
    }

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

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

} /* TTMERGE_Setup () */

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

    /* Multi-Instance function                                       */
    RetErr |= STTST_RegisterCommand("TSMERGE_SETUP",  TTMERGE_Setup,  "<ServiceMode>Setup TSMERGE");

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

    return( RetErr );

} /* end of TSMERGE_InitCommand */

#endif

/* EOF --------------------------------------------------------------------- */