testtool.c

sttesttool.rar的标准testtool.rar驱动

    return(IsBad || STTST_AssignInteger(result_sym_p, (S32)value, FALSE));
}
#endif

/* ========================================================================
testtool command : peek a 32 bit value
=========================================================================== */
#ifdef NO_STAPIGAT
static BOOL PeekMemory(STTST_Parse_t *pars_p, char *result_sym_p)
{
    STTST_TagCurrentLine(pars_p, "NO_STAPIGAT defined");

    return(TRUE || STTST_AssignInteger(result_sym_p, 0, FALSE));
}
#else
static BOOL PeekMemory(STTST_Parse_t *pars_p, char *result_sym_p)
{
    BOOL IsBad;
    long base;
    long def_base;
    long value = 0;

    /* get default value from symbol variables */
    STTST_EvaluateInteger("BASEADDRESS", (S32 *)&def_base, 10);

    IsBad = STTST_GetInteger(pars_p, (S32)def_base, (S32 *)&base);
    if (IsBad)
    {
        STTST_TagCurrentLine(pars_p, "expected base address");
    }
#ifdef FORCE_32BITS_ALIGN
    else if ((base & 0x03) != 0)
    {
        STTST_TagCurrentLine(pars_p, "address must be 32 bits aligned");
        IsBad = TRUE;
    }
#endif
    if (!IsBad)
    {
#ifdef ST_OSLINUX
        value = (long)STAPIGAT_Phys_Read((U32*)base);
#else
        value = *((volatile long*)base);
#endif
        STTBX_Print(("read 0x%x (hex) = %d (dec) \n",(int) value, (int) value));
    }
    return(IsBad || STTST_AssignInteger(result_sym_p, (S32)value, FALSE));
}
#endif
/* ========================================================================
testtool command : poke a 32 bit value
=========================================================================== */
#ifdef NO_STAPIGAT
static BOOL PokeMemory(STTST_Parse_t *pars_p, char *result_sym_p)
{
    STTST_TagCurrentLine(pars_p, "NO_STAPIGAT defined");

    return(TRUE || STTST_AssignInteger(result_sym_p, 0, FALSE));
}
#else
static BOOL PokeMemory(STTST_Parse_t *pars_p, char *result_sym_p)
{
    BOOL IsBad;
    long base;
    long value;
    long def_base;
    long def_value;

    /* get default values from symbol variables */
    STTST_EvaluateInteger("BASEADDRESS", (S32 *)&def_base, 10);
    STTST_EvaluateInteger("DATAVALUE", (S32 *)&def_value, 10);

    IsBad = STTST_GetInteger(pars_p, (S32)def_base, (S32 *)&base);
    if (IsBad)
    {
        STTST_TagCurrentLine(pars_p, "Invalid base address");
    }
    else
    {
        IsBad = STTST_GetInteger(pars_p, (S32)def_value, (S32 *)&value);
        if (IsBad)
        {
            STTST_TagCurrentLine(pars_p, "Invalid data value");
        }
#ifdef FORCE_32BITS_ALIGN
        else if ((base & 0x03) != 0)
        {
            STTST_TagCurrentLine(pars_p, "Address must be 32 bits aligned");
            IsBad = TRUE;
        }
#endif
    }
    if (!IsBad)
    {
#ifdef ST_OSLINUX
        STAPIGAT_Phys_Write((U32*)base, (U32)value);
#else
        *((volatile long*) base) = value;
#endif
    }
    return(IsBad || STTST_AssignInteger(result_sym_p, (S32)value, FALSE));
}
#endif
/****************************************************************************/
/**************************** OTHER COMMANDS ********************************/
/****************************************************************************/
/* ========================================================================
testtool command : pauses and deschedule
=========================================================================== */
static BOOL WaitTime(STTST_Parse_t *pars_p, char *result_sym_p)
{
    BOOL IsBad;
    long time;
    int  ip_char;
    UNUSED_PARAMETER(result_sym_p);

    IsBad = STTST_GetInteger(pars_p, (S32)1, (S32 *)&time);
    if (IsBad || (time < 0) || (time > 100000))
    {
        IsBad = TRUE;
        STTST_TagCurrentLine(pars_p, "Expected number of milliseconds to wait");
    }
    else
    {
        /* CL modif July 2nd 2001 */
        /* uses ST_GetClocksPerSecond() to take CPU speed into account */
#ifdef ST_OS21
        task_delay((osclock_t)((time*ST_GetClocksPerSecond())/1000)); /* wait x millisec. */
#else
		/* Take care of ST_GetClocksPerSecond() granularity. If the number of clock per   */
        /* second is huge, then "time*(ST_GetClocksPerSecond" may overflow. So consider   */
        /* the max limit 100000 that may allow a max tempo of 21474 ms.                   */
        if (ST_GetClocksPerSecond() > 1000000)
        {
			task_delay((unsigned int)(((U32)time*(ST_GetClocksPerSecond()/1000))));
        }
        else
        {
			task_delay((unsigned int)((time*ST_GetClocksPerSecond())/1000)); /* wait x millisec. */
        }
#endif
        /* end of CL modif July 2nd 2001*/
        /* task_delay((unsigned int)time*15.625); wait x sec. */
        /* test for user abort during wait */
        /*ip_char = pollkey();FQ*/
#ifndef ARCHITECTURE_ST200
        STTBX_InputPollChar((char *) (&ip_char));
        if (ip_char == 0x1b)
        {
            IsBad = TRUE;
        }
#endif
    }
    return(IsBad);
}

#ifndef ST_OSLINUX
/* ========================================================================
testtool command : raise an interrupt
=========================================================================== */
static BOOL RaiseInterrupt(STTST_Parse_t *pars_p, char *result_sym_p)
{
    BOOL IsBad;
    long level;
    UNUSED_PARAMETER(result_sym_p);

    IsBad = STTST_GetInteger(pars_p, (S32)0, (S32 *)&level);
    if (IsBad || (level < 0) || (level >= 8))
    {
        IsBad = TRUE;
        STTST_TagCurrentLine(pars_p, "Expected interrupt level");
    }
    else
    {
        interrupt_raise_number((int)level);
    }
    return(IsBad);
}
#endif

/* ========================================================================
testool command : display processes and Interrupts
=========================================================================== */
/***static BOOL MemoryInfo (STTST_Parse_t *pars_p, char *result_sym_p)
{
BOOL       IsBad = FALSE;

#if 0
char          *ptr;
int           i;
int           unused;

extern local_interrupt_control_t   interrupt_control[NUM_INTERRUPT_LEVELS];

task_t*  Task;
int*     Stack;
int*     Stack_limit;
int      Unused;
char     PriString[16];
extern task_t*              TaskListHead;


STTBX_Report((STTBX_REPORT_LEVEL_INFO,"****** Interrupts stack *******\n"));
STTBX_Report((STTBX_REPORT_LEVEL_INFO,"Level   Size    Used\n"));
for (i = 0; i < NUM_INTERRUPT_LEVELS; i++)
{
    unused = 0;
    ptr = (char *) interrupt_control[i].stack_base;
    while(*ptr == 0x55)
    {
    unused++;
    ptr++;
    }
    IsBad |= (unused == 0);

    STTBX_Report((STTBX_REPORT_LEVEL_INFO,
        "%-8d%-8d%d%s\n",
        i,
        interrupt_control[i].stack_size,
        interrupt_control[i].stack_size - unused,
        unused == 0 ? "*" : ""));
}
*/
/*report (severity_info, "\n****** Processes stack ********\n");
report (severity_info,"%-30s %-6s %-6s %-8s %-4s\n",*/
/*  STTBX_Report((STTBX_REPORT_LEVEL_INFO,"\n****** Processes stack ********\n"));
STTBX_Report((STTBX_REPORT_LEVEL_INFO,"%-30s %-6s %-6s %-8s %-4s\n",
    "Name",
    "Size",
    "Used",
    "Base",
    "Priority"));
task_lock ();
Task = TaskListHead;
while (Task->task_next != NULL)
{ */
/* This will discard the "root" process */
/*    Unused = 0;
    Stack  = (int*)Task->task_stack_base;
    Stack_limit = Stack + (Task->task_stack_size / sizeof (int)); */
    /* Skip task name first */
/*    while ((*Stack != 0xaaaaaaaa) && (Stack < Stack_limit))
    {
    Stack++;
    Unused++;
    } */
    /* Skip unused */
/*    while ((*Stack == 0xaaaaaaaa) &&  (Stack < Stack_limit))
    {
    Stack++;
    Unused++;
    }

    if (Stack == Stack_limit)
    Unused = 0;
    if (Task->task_tdesc != NULL)
    sprintf (PriString, "%d", Task->task_tdesc->tdesc_priority);
    else
    strcpy (PriString, "High");

    STTBX_Report((STTBX_REPORT_LEVEL_INFO,"%-30s %-6d %-6d %p %-4s\n",
        (char*)(Task->task_stack_base),
        Task->task_stack_size,
        Task->task_stack_size - (Unused * 4),
        Task->task_stack_base,
        PriString));
    Task = Task->task_next;
}
task_unlock ();

#endif

return(IsBad);
}***/
/* ========================================================================
cli_setup : register default routines
=========================================================================== */
static BOOL cli_setup(void)
{
    STTST_RegisterCommand("BPEEK", PeekByteMemory,
                "<address> Extracts 8 bit memory value");
    STTST_RegisterCommand("BPOKE", PokeByteMemory,
                "<address><value> Sets 8 bit memory value");
    STTST_RegisterCommand("SPEEK", PeekShortMemory,
                "<address> Extracts 16 bit memory value");
    STTST_RegisterCommand("SPOKE", PokeShortMemory,
                "<address><value> Sets 16 bit memory value");
    STTST_RegisterCommand("COPY", CopyMemory,
                "<address><range><newaddress> Copies local memory contents");
    STTST_RegisterCommand("DISPLAY", DisplayMemory,
                "<address><range> Displays local memory contents\n\t     default = BASEADDRESS RANGE\n\t     <address><range><filename><option> Dump local memory contents in a file\n\t     option= W|A for write|append (default is w)\n" );
    STTST_RegisterCommand("FILL", FillMemory,
                "<address><range><value> Fill local memory with 32bits value");
#ifndef ST_OSLINUX
    STTST_RegisterCommand("INTERRUPT", RaiseInterrupt,
                "<level> Raise interrupt internally");
#endif
    /*STTST_RegisterCommand("MEMORY", MemoryInfo,
                "Dump system memory usage");*/
    STTST_RegisterCommand("PEEK", PeekMemory,
                "<address> Extracts 32 bit memory value");
    STTST_RegisterCommand("POKE", PokeMemory,
                "<address><value> Sets 32 bit memory value");
    STTST_RegisterCommand("SEARCH", FindString,
                "<data><address><range><max> Searchs data in local memory\n\t     default: data=DATAVALUE addr=BASEADDRESS range=RANGE max_occurences=1\n\t     the 1st match address is returned (0 if not found)");
    STTST_RegisterCommand("SEARCH_NEXT", FindNextString,
                "Continues the previous search in local memory");
    STTST_RegisterCommand("WAIT", WaitTime,
                "<millisecs> Pause for a time period (available with 1 tick each 64 microsec)");
    /*STTST_RegisterCommand("ZAP", io_zap,
                "Change I/O controls UART/CONSOLE"); FQ */

    STTST_AssignInteger("ZERO", (S32)0, TRUE);
    STTST_AssignInteger("BASEADDRESS", (S32)0x80000000, FALSE);
    STTST_AssignInteger("RANGE", (S32)0x100, FALSE);
    STTST_AssignInteger("DATAVALUE", (S32)0, FALSE);
    STTST_AssignInteger("ADDRESSVALUE", (S32)0x80000000, FALSE);

    return(FALSE);
}

/****************************************************************************/
/**************************  EXTERNAL FUNCTIONS *****************************/
/****************************************************************************/

/***************************************************************
Name : STTST_GetRevision
Description : Retrieve the driver revision
Parameters : none
Return : driver revision
****************************************************************/
ST_Revision_t STTST_GetRevision(void)
{
    static const char Revision[]="STTST-REL_3.3.0";

    /* Revision string format: STXXX-REL_x.x.x
                                 /       \ \ \__patch release number  }
                            API name      \ \__minor release number  } revision number
                                           \__major release number  }
    */

    return((ST_Revision_t)Revision);
} /* End of STTST_GetRevision() */


/* ========================================================================
Initialize the command line interpreter
=========================================================================== */
BOOL STTST_Init( const STTST_InitParams_t * const InitParam_p)
{
    memcpy( (char *)&sttst_InitParams,
            (const char *)InitParam_p,
            sizeof(sttst_InitParams) );
    if ( sttst_InitParams.CPUPartition_p == NULL )
    {
        return(TRUE);
    }
    if ( sttst_InitParams.NbMaxOfSymbols==0 )
    {
        sttst_InitParams.NbMaxOfSymbols = 1000;
    }
    sttst_CliInit( cli_setup, sttst_InitParams.NbMaxOfSymbols, 10);
    STTST_RunMode = STTST_INTERACTIVE_MODE;
    return(FALSE);
}

/* ========================================================================
Start the command line interpreter
=========================================================================== */
BOOL STTST_Start(void)
{
    sttst_CliRun("Testtool> ", sttst_InitParams.InputFileName);

    return(FALSE);
}

/* ========================================================================
Set Testtool mode
=========================================================================== */
BOOL STTST_SetMode(STTST_RunningMode_t RunMode)
{
    BOOL RetErr;

    if ( ( RunMode | STTST_SUPPORTED_MODES_MASK ) != STTST_SUPPORTED_MODES_MASK )
    {
        RetErr = TRUE; /* unknown mode */
        STTST_RunMode = STTST_INTERACTIVE_MODE; /* default mode */
    }
    else
    {
        STTST_RunMode = RunMode;
        RetErr = FALSE;
    }
    return(RetErr);
}

/* ========================================================================
Terminates the command line interpreter
=========================================================================== */
BOOL STTST_Term(void)
{
    sttst_CliTerm();
    return(FALSE);
}


#ifdef __cplusplus
}
#endif