sdram_main.c

Freescale MCF5445evb 参考测试代码

/*
 * \file    sdram_main.c
 * \brief   Command line interface for SDRAM validation tests
 * \version $Revision: 1.5 $
 * \author  Michael Norman
 */

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

#define SDRAM_CLI

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

int sdram_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**);

const char PROMPT[] = "SDRAM> ";

UIF_CMD UIF_CMDTAB[] =
{
    UIF_CMDS_ALL
    {"rd",      0,0,0,cmd_rd,       "Display all SDRAMC registers",""},
    {"burstr",  0,1,0,cmd_burstr,   "Perform burst read test","<addr>"},
    {"burstw",  0,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 SDRAM device test","<addr> <bytes> <access-size>"},
    {"inv",     0,0,0,cmd_invalid,  "Perform invalid access test",""},
    {"selfref", 0,0,0,cmd_selfref,  "Perform self-refresh test",""},
    {"pwrdown", 0,0,0,cmd_pwrdown,  "Perform power-down test",""},
    {"all",     0,0,0,cmd_all,      "Perform all SDRAM 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 SDRAM_CLI
    printf("Running all SDRAM tests...");
    if (sdram_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("*                  SDRAM 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)
{
    sdram_register_dump();
}
/********************************************************************/
void
cmd_burstr (int argc, char **argv)
{
    ADDRESS addr = (ADDRESS) SDRAM_ADDRESS;
    int result;

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

    if (argc > 1)
    {
        addr = (ADDRESS) get_value(argv[1],&result,16);
        if (result == 0)
        {
            printf(INVALUE,argv[1]);
            return;
        }
    }
    if (sdram_burst_write(addr))
        printf("FAILED\n");
    else 
        printf("passed\n");
}
/********************************************************************/
void
cmd_data (int argc, char **argv)
{
    ADDRESS addr;
    int result, access;
    
    if (sdram_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 (sdram_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 (sdram_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)
{
    sdram_invalid_access();
}
/********************************************************************/
void
cmd_selfref (int argc, char **argv)
{
    if (sdram_self_refresh())
        printf("FAILED\n");
    else
        printf("passed\n");
}
/********************************************************************/
void
cmd_pwrdown (int argc, char **argv)
{
    if (sdram_power_down())
        printf("FAILED\n");
    else
        printf("passed\n");
}
/********************************************************************/
void
cmd_all (int argc, char **argv)
{
    if (sdram_all_tests())
        printf("FAILED\n");
    else
        printf("passed\n");
}
/********************************************************************/
/*!
 * \brief Get SDRAM 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
sdram_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 < 0x40000000) || (*addr > 0x80000000))
    {
        printf(INVALUE,arg);
        return 1;
    }
    
    return 0;        
}
/********************************************************************/