srram_main.c

Freescale MCF5445evb 参考测试代码

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

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

#define SRAM_CLI

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

int sram_get_address(char *, ADDRESS *);

/*
 * Setup user interface
 */
void mainloop (void);
void cmd_all (int, char**);
void cmd_burstr (int, char**);
void cmd_burstw (int, char**);
void cmd_data (int, char**);
void cmd_addr (int, char**);
void cmd_device (int, char**);

const char PROMPT[] = "SRAM> ";

UIF_CMD UIF_CMDTAB[] =
{
    UIF_CMDS_ALL
    {"burstr",  0,1,0,cmd_burstr,   "Perform burst read tests","<addr>"},
    {"burstw",  0,1,0,cmd_burstw,   "Perform burst write tests","<addr>"},
    {"data",    2,2,0,cmd_data,     "Perform data-bus tests","<addr> <access-size>"},
    {"addr",    3,3,0,cmd_addr,     "Perform addr-bus tests","<addr> <bytes> <access-size>"},
    {"device",  3,3,0,cmd_device,   "Perform SRAM device","<addr> <bytes> <access-size>"},
    {"all",     0,0,0,cmd_all,      "Perform all SRAM 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 SRAM_CLI
    printf("Running all SRAM tests.\n");
    cmd_all(0, NULL);
#else    
	char ch;
		
    printf("\n");
    printf("**************************************************\n");
    printf("*                                                *\n");
    printf("*                  SRAM 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_burstr (int argc, char **argv)
{
    ADDRESS addr = (ADDRESS) SRAM_ADDRESS;
    int result;

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

    if (argc > 1)
    {
        addr = (ADDRESS) get_value(argv[1],&result,16);
        if (result == 0)
        {
            printf(INVALUE,argv[1]);
            return;
        }
    }
    if (sram_burst_write(addr))
        printf("FAILED\n");
    else 
        printf("passed\n");
}
/********************************************************************/
void
cmd_data (int argc, char **argv)
{
    ADDRESS addr;
    int result, access;
    
    if (sram_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 (sram_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 (sram_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_all (int argc, char **argv)
{
    ADDRESS addr = (ADDRESS) SRAM_ADDRESS;
    
    if (sram_data_test(addr))
        printf("FAILED: sram_data_test()\n");
    else if (sram_addr_test(addr+(SRAM_SIZE/8*3), SRAM_SIZE/4))
        printf("FAILED: sram_addr_test()\n");
    else if (sram_device_test(addr+(SRAM_SIZE/16*7), SRAM_SIZE/8))
        printf("FAILED: sram_device_test()");
    if (sram_burst_write(addr))
        printf("FAILED: sram_burst_write()\n");
    else if (sram_burst_read(addr))
        printf("FAILED: sram_burst_read()\n");
    else
        printf("All SRAM tests passed.\n");
}
/********************************************************************/
/*!
 * \brief Get SRAM 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
sram_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 < 0x80000000) || (*addr > 0x90000000))
    {
        printf(INVALUE,arg);
        return 1;
    }
    
    return 0;        
}
/********************************************************************/