flexbus_main.c

Freescale MCF5445evb 参考测试代码

/*
 * \file    flexbus_main.c
 * \brief   Command line interface for Flexbus validation tests
 * \version $Revision: 1.1 $
 * \author  Michael Norman
 */

#include "common.h"
#include "uif.h"
#include "flexbus_tests.h"
#include "memtest.h"

#define flexbus_CLI

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

int flexbus_get_address(char *, ADDRESS *);

/*
 * Setup user interface
 */
void mainloop (void);
void cmd_all (int, char**);
void cmd_rd (int, char**);
void cmd_burstr (int, char**);
void cmd_burstw (int, char**);
void cmd_data (int, char**);
void cmd_addr (int, char**);
void cmd_invalid (int, char**);
void cmd_selfref (int, char**);
void cmd_pwrdown (int, char**);
void cmd_device (int, char**);
void cmd_jitter (int, char**);

const char PROMPT[] = "flexbus> ";

UIF_CMD UIF_CMDTAB[] =
{
    UIF_CMDS_ALL
    {"rd",      0,0,0,cmd_rd,       "Display all flexbusC registers",""},
    {"burstr",  1,1,0,cmd_burstr,   "Perform burst read test","<addr>"},
    {"burstw",  1,1,0,cmd_burstw,   "Perform burst write test","<addr>"},
    {"data",    2,2,0,cmd_data,     "Perform data-bus test","<addr> <access-size>"},
    {"addr",    3,3,0,cmd_addr,     "Perform addr-bus test","<addr> <bytes> <access-size>"},
    {"device",  3,3,0,cmd_device,   "Perform flexbus device test","<addr> <bytes> <access-size>"},
    {"inv",     0,0,0,cmd_invalid,  "Perform invalid access test",""},
    {"jit",     0,1,0,cmd_jitter,   "Perform FBCLK jitter test","<min|max>"},
    {"all",     0,0,0,cmd_all,      "Perform all flexbus tests",""},
};
const int UIF_NUM_CMD = UIF_CMDTAB_SIZE;

UIF_SETCMD UIF_SETCMDTAB[] = {"",0,0,NULL,""};
const int UIF_NUM_SETCMD = 0;

/********************************************************************/
void 
main (void)
{
#ifndef flexbus_CLI
    printf("Running all flexbus tests...");
    if (flexbus_all_tests())
        printf("FAILED\n");
    else
        printf("passed\n");
#else    
	char ch;
	
	cpu_icache_enable(0x0, SIZE_1G);
		
    printf("\n");
    printf("**************************************************\n");
    printf("*                                                *\n");
    printf("*                  flexbus Utility                 *\n");
    printf("*                                                *\n");
    printf("**************************************************\n");
    printf(HELPMSG);
    printf("\n");

    mainloop();
#endif
}
/********************************************************************/
void
mainloop (void)
{
    /* Enable interrupts to the core */
    mcf5xxx_irq_enable();

    while (TRUE)
    {
        printf(PROMPT);
        run_cmd();
    }
}
/********************************************************************/
void
cmd_rd (int argc, char **argv)
{
    flexbus_register_dump();
}
/********************************************************************/
void
cmd_burstr (int argc, char **argv)
{
    ADDRESS addr;
    int result;

    addr = (ADDRESS) get_value(argv[1],&result,16);
    if (result == 0)
    {
        printf(INVALUE,argv[1]);
        return;
    }
    
    if (flexbus_burst_read(addr))
        printf("FAILED\n");
    else 
        printf("passed\n");
}
/********************************************************************/
void
cmd_burstw (int argc, char **argv)
{
    ADDRESS addr;
    int result;

    addr = (ADDRESS) get_value(argv[1],&result,16);
    if (result == 0)
    {
        printf(INVALUE,argv[1]);
        return;
    }

    if (flexbus_burst_write(addr))
        printf("FAILED\n");
    else 
        printf("passed\n");
}
/********************************************************************/
void
cmd_data (int argc, char **argv)
{
    ADDRESS addr;
    int result, access;
    
    if (flexbus_get_address(argv[1], &addr))
        return;
    access = (int) get_value(argv[2],&result,10);
    if (result == 0)
    {
        printf(INVALUE,argv[2]);
        return;
    }
    switch (access)
    {
        case 8:
            result = memtest_databus_8((uint8*)addr);
            break;
        case 16:
            result = memtest_databus_16((uint16*)addr);
            break;
        case 32:
            result = memtest_databus_32((uint32*)addr);
            break;
        default:
            printf(INVALUE,argv[2]);
            return;
    }
    
    if (result != 0)
        printf("FAILED\n");
    else 
        printf("passed\n");
    
}
/********************************************************************/
void
cmd_addr (int argc, char **argv)
{
    ADDRESS addr;
    int result, bytes, access;
    
    if (flexbus_get_address(argv[1], &addr))
        return;
    bytes = (int) get_value(argv[2],&result,16);
    if (result == 0)
    {
        printf(INVALUE,argv[2]);
        return;
    }
    access = (int) get_value(argv[3],&result,10);
    if (result == 0)
    {
        printf(INVALUE,argv[3]);
        return;
    }
    switch (access)
    {
        case 8:
            result = (int) memtest_addrbus_8((uint8*)addr, bytes);
            break;
        case 16:
            result = (int) memtest_addrbus_16((uint16*)addr, bytes);
            break;
        case 32:
            result = (int) memtest_addrbus_32((uint32*)addr, bytes);
            break;
        default:
            printf(INVALUE,argv[1]);
    }
    
    if (result != 0)
        printf("FAILED\n");
    else 
        printf("passed\n");
}
/********************************************************************/
void
cmd_device (int argc, char **argv)
{
    ADDRESS addr;
    int result, access, bytes;
    
    if (flexbus_get_address(argv[1], &addr))
        return;
    bytes = (ADDRESS) get_value(argv[2],&result,16);
    if (result == 0)
    {
        printf(INVALUE,argv[2]);
        return;
    }
    access = (int) get_value(argv[3],&result,10);
    if (result == 0)
    {
        printf(INVALUE,argv[3]);
        return;
    }
    switch (access)
    {
        case 8:
            result = (int) memtest_device_8((uint8*)addr, bytes);
            break;
        case 16:
            result = (int) memtest_device_16((uint16*)addr, bytes);
            break;
        case 32:
            result = (int) memtest_device_32((uint32*)addr, bytes);
            break;
        default:
            printf(INVALUE,argv[1]);
    }
    
    if (result != 0)
        printf("FAILED\n");
    else 
        printf("passed\n");
}
/********************************************************************/
void
cmd_invalid (int argc, char **argv)
{
    flexbus_invalid_access();
}
/********************************************************************/
void
cmd_jitter (int argc, char **argv)
{
    int max = TRUE;
    
    if (argc == 2)
    {
        if (strcasecmp(argv[1], "min") == 0)
            max = FALSE;
        else if (strcasecmp(argv[1], "max") == 0)
            max = TRUE;
        else
            printf("Invalid argument: assuming \"max\"\n");
    }
    
    flexbus_jitter(max);
}
/********************************************************************/
void
cmd_all (int argc, char **argv)
{
    if (flexbus_all_tests())
        printf("FAILED\n");
    else
        printf("passed\n");
}
/********************************************************************/
/*!
 * \brief Get Flexbus address from command line
 * \param arg   Command line argument to be converted to an address
 * \param addr  Pointer
 * \return  0 for result, non-zero for failure
 */
int
flexbus_get_address(char *arg, ADDRESS *addr)
{
    int result, access;
    
    *addr = (ADDRESS) get_value(arg,&result,16);
    if (result == 0)
    {
        printf(INVALUE,arg);
        return 1;
    }
    if ((*addr < 0x00000000) || (*addr > 0x80000000) &&
        (*addr < 0xC0000000) || (*addr > 0xE0000000))
    {
        printf(INVALUE,arg);
        return 1;
    }
    
    return 0;        
}
/********************************************************************/