clkrvsim.c

st40 clock driver source code. 用于st40 linux

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

File Name   : clkrvsim.c

Description : Clock Recovery API Routines

Copyright (C) 2006, STMicroelectronics

Revision History    :

References  :

$ClearCase (VOB: stclkrv)S

stclkrv.fm "Clock Recovery API"

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


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

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <time.h>
#include <math.h>

#include "stclkrv.h"
#include "stdevice.h"
#include "stevt.h"
#include "sttbx.h"

#include "clkrvsim.h"
#include "clkrvreg.h"

/* Private Constants -------------------------------------------------- */

#define K                           1000
#define M                           (K * K)
#define TICKS_IN_SECOND             ST_GetClocksPerSecond  /* for task delay of 1 sec */

#ifdef ST_OS21
#define TASK_STACK_SIZE             8*2048
#else
#define TASK_STACK_SIZE             2048
#endif
#define SD_VIDEO_FREQ               27000000
#define CLKRVSIM_ENCODER_MAX_FREQ   27006000
#define CLKRVSIM_ENCODER_MIN_FREQ   26994000

#define CLKRVSIM_JITTER_MIN         0
#define CLKRVSIM_JITTER_MAX         100000

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

/* Store EVT Context */
typedef struct
{
    ST_DeviceName_t      EVTDevNamPcr;
    STEVT_Handle_t       EVTHandlePcr;

}CLKRVSIM_EVT_t;

/* Task States */
typedef enum
{
    NOT_INITIALIZED = 0,
    INITIALIZED,
    RUNNING

}CLKRVSIM_TaskState_t;

/* Task Control Block */
typedef struct
{
    FILE*                  Logfile_p;               /* Pointer to Log File */
    tdesc_t                simulator_desc;
    void                   *SimulatorTaskStack_p;
    semaphore_t            *TaskSemaphore_p;
    task_t                 *simulator_task_p;
    CLKRVSIM_TaskState_t   State;                   /* Simulator Task State */
    ST_Partition_t         *SysPartition_p;         /* Memory partition to use (mi) */
    ST_Partition_t         *InternalPartition_p;    /* Memory partition to use (mi) */

}CLKRVSIM_TCB_t;

/* Simulator Context */
typedef struct
{
    U32                     EncoderFrequency;     /* Encoder Frequency From Test App */
    U32                     Jitter;               /* Jitter value */
    U8                      StreamStatus;         /* Real Time disturbance to be introduced */
    U32                     PCR_Interval;         /* In ms */
    U32                     PCR_DriftThreshold;
    U8                      DriftCorrection;      /* Flag to check if DriftCorrection is ON */
#ifdef ST_OS21                                    /* clock recovery module HW interrupt number */
    interrupt_name_t        InterruptNumber;
#else
    U32                     InterruptNumber;
#endif
    CLKRVSIM_TCB_t          TaskContext;
    CLKRVSIM_EVT_t          Evt;
    FILE                    *TestFile_p;          /* File Pointer for a File Read Test */
    BOOL                    FileTest;             /* Flag to check for File Read Test */
    BOOL                    SimReset;             /* Flag to check if Simulator needs ot be reset */

}CLKRVSIM_Context_t;

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

U32                         CLKRVSIM_RegArray[CLKRVSIM_REG_ARRAY_SIZE];
STEVT_EventID_t             CLKRVEventIDSIM;
#ifdef ST_5188
static STDEMUX_EventData_t  PcrDataSim;
#else
static STPTI_EventData_t    PcrDataSim;
#endif
static CLKRVSIM_Context_t   *ControlObject_p;      /* Instance of the Simulator */

/* Globals ------------------------------------------------------------- */




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

#define GET_SDIV(a) ((1)<<((a) + 1))

/* Private Function prototypes ---------------------------------------- */

/* EVT Related */
static ST_ErrorCode_t CLKRVSIM_EVTInit(void);
static ST_ErrorCode_t CLKRVSIM_EVTTerm(void);

static S32 NetworkJitter(S32 MaxJitter);

/* Main Simulator Task */
void SimulatorTask(void *voidptr);
void exit_simulator_task(task_t* task, int param);

/* Register Read/Write */
__inline void ClkrvSim_RegWrite(U32 *BaseAddress, U32 Register, U32 Value);
__inline void ClkrvSim_RegRead(U32 *BaseAddress, U32 Register, U32* ReadVal );

/* externs ------------------------------------------------------------ */
#define CLKRV_MAX_SAMPLES  5000
extern U32 ClkrvDbg[13][CLKRV_MAX_SAMPLES];
extern U32 Clkrv_Slave_Dbg[5][CLKRV_MAX_SAMPLES];
extern U32 SampleCount;

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

/****************************************************************************
Name         : CLKRVSIM_Init()

Description  : Initializes the Simulator

Parameters   : Pointer to STCLKRVSIM_InitParams_t
               Double Pointer to CLKRVBaseAddress

Return Value : ST_ErrorCode_t
               ST_NO_ERROR               Successful completion
               ST_ERROR_NO_MEMORY        Memory Allocation Faliure
See Also     :
 ****************************************************************************/

ST_ErrorCode_t STCLKRVSIM_Init(STCLKRVSIM_InitParams_t *SimInitParams_p,CLKRVBaseAddress **BaseAddr_p)
{
    ST_ErrorCode_t  Error  = ST_NO_ERROR;

    /* Return Base Address of Reg Array */
    memset(CLKRVSIM_RegArray,0,(CLKRVSIM_REG_ARRAY_SIZE * 4));
    *BaseAddr_p =  CLKRVSIM_RegArray ;

    ControlObject_p = (CLKRVSIM_Context_t*) memory_allocate_clear(SimInitParams_p->SysPartition_p,
                                                                    1,sizeof(CLKRVSIM_Context_t));
    if (ControlObject_p == NULL)
    {
         return ST_ERROR_NO_MEMORY;
    }

    ControlObject_p->TaskContext.SysPartition_p       = SimInitParams_p->SysPartition_p;
    ControlObject_p->TaskContext.InternalPartition_p  = SimInitParams_p->InternalPartition_p;
    ControlObject_p->InterruptNumber                  = SimInitParams_p->InterruptNumber;
    strcpy(ControlObject_p->Evt.EVTDevNamPcr,SimInitParams_p->EVTDevNamPcr);

    /* create semaphore */
    ControlObject_p->TaskContext.TaskSemaphore_p = STOS_SemaphoreCreateFifoTimeOut(NULL, 1);

    ControlObject_p->TaskContext.State = INITIALIZED;
    
    Error = STOS_TaskCreate((void(*)(void *))SimulatorTask,
                                        NULL,
                                        ControlObject_p->TaskContext.SysPartition_p ,
                                        TASK_STACK_SIZE,
                                        &ControlObject_p->TaskContext.SimulatorTaskStack_p,
                                        ControlObject_p->TaskContext.SysPartition_p ,
                                        &ControlObject_p->TaskContext.simulator_task_p,
                                        &ControlObject_p->TaskContext.simulator_desc,
                                        (int)MAX_USER_PRIORITY,
                                        "Simulator_Task",
                                        (task_flags_t)0);
    if(Error != ST_NO_ERROR)
    {
        STTBX_Print(("STC_PCR Task Init failed\n"));
        Error = ST_ERROR_NO_MEMORY;     /* Error for OS Call faliure */
    }

    if(Error == ST_NO_ERROR)
    {
        Error = CLKRVSIM_EVTInit();
    }

    if(Error == ST_NO_ERROR)
    {
        task_onexit_set(exit_simulator_task);
    }

    return Error;
}

/****************************************************************************
Name         : CLKRVSIM_Term()

Description  : Terminate Simulator

Parameters   : void

Return Value : ST_ErrorCode_t
               ST_NO_ERROR               Successful completion

See Also     :
 ****************************************************************************/

ST_ErrorCode_t STCLKRVSIM_Term(void)
{
    ST_ErrorCode_t Error =  ST_NO_ERROR;
    task_t        *task_p;

    if(ControlObject_p->TaskContext.State == INITIALIZED)
    {
        CLKRVSIM_EVTTerm();
        task_p = ControlObject_p->TaskContext.simulator_task_p;

        ControlObject_p->TaskContext.State = NOT_INITIALIZED;

        task_kill(ControlObject_p->TaskContext.simulator_task_p, 5, 0);
        STOS_TaskWait(&task_p, TIMEOUT_INFINITY);
        STOS_TaskDelete ( ControlObject_p->TaskContext.simulator_task_p,
                          ControlObject_p->TaskContext.SysPartition_p ,
                          ControlObject_p->TaskContext.SimulatorTaskStack_p,
                          ControlObject_p->TaskContext.SysPartition_p);
        STOS_SemaphoreDelete(NULL, ControlObject_p->TaskContext.TaskSemaphore_p);
        memory_deallocate(ControlObject_p->TaskContext.SysPartition_p,ControlObject_p);
    }
    else
    {
        STTBX_Print(("STCLKRVSIM_Term called in Invalid State\n"));
        Error = ST_ERROR_BAD_PARAMETER;
    }

    return  Error;

}


/****************************************************************************
Name         : CLKRVSIM_EVTInit

Description  : Initialize EVT and Register STPTI_EVENT_PCR_RECEIVED_EVT Event

Parameters   : void

Return Value : ST_ErrorCode_t

See Also     :
****************************************************************************/

static ST_ErrorCode_t CLKRVSIM_EVTInit(void)
{
    STEVT_InitParams_t   EVTInitPars;
    STEVT_OpenParams_t   EVTOpenParsPCR;
    ST_ErrorCode_t       EvtError = ST_NO_ERROR;

    memset(&EVTInitPars,'\0',sizeof(EVTInitPars));

    /*  Setup Event registration for notification of PCR_RECEIVED
     *  event and callback to ActionPCR
     */
    EVTInitPars.EventMaxNum       = 3;
    EVTInitPars.ConnectMaxNum     = 2;
    EVTInitPars.SubscrMaxNum      = 9;
    EVTInitPars.MemoryPartition   = ControlObject_p->TaskContext.SysPartition_p;
    EVTInitPars.MemorySizeFlag    = STEVT_UNKNOWN_SIZE;

    EvtError = STEVT_Init(ControlObject_p->Evt.EVTDevNamPcr,&EVTInitPars);
    if(EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("ERROR:STEVT_Init in CLKRVSIM_EVTInit\n"));
    }

    /* Call STEVT_Open() so that we can subscribe to events */

    EvtError = STEVT_Open(ControlObject_p->Evt.EVTDevNamPcr,
                          &EVTOpenParsPCR,
                          &(ControlObject_p->Evt.EVTHandlePcr));
    if(EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("ERROR:STEVT_Open in CLKRVSIM_EVTInit\n"));
    }

#ifdef ST_5188
    EvtError = STEVT_Register(ControlObject_p->Evt.EVTHandlePcr,
                             (U32)STDEMUX_EVENT_PCR_RECEIVED_EVT,
                             &CLKRVEventIDSIM );
#else
    EvtError = STEVT_Register(ControlObject_p->Evt.EVTHandlePcr,
                             (U32)STPTI_EVENT_PCR_RECEIVED_EVT,
                             &CLKRVEventIDSIM );
#endif
    if(EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("ERROR:STEVT_Register in CLKRVSIM_EVTInit\n"));
    }

    return EvtError;
}

/****************************************************************************
Name         : CLKRVSIM_EVTTerm

Description  : Terminate EVT

Parameters   : void