m54451evb_tests.c

Freescale MCF5445evb 参考测试代码

/*! 
 * \file    jamaica_tests.c
 * \brief   Jamaica hardware test routines
 * 
 * This file contains platform specific test routines.
 *
 * \author  Michael Norman
 * \version $Revision: 1.1 $
 */

#include "common.h"
#include "m54451evb_tests.h"
#include "memtest.h"
#include "amd_flash.h"

int test_data[] = {
    0x00112233, 0x44556677, 0x8899AABB, 0xCCDDEEFF,
    0x00112233, 0x44556677, 0x8899AABB, 0xCCDDEEFF,
    0x00112233, 0x44556677, 0x8899AABB, 0xCCDDEEFF,
    0x00112233, 0x44556677, 0x8899AABB, 0xCCDDEEFF,
    0x00001111, 0x22223333, 0x44445555, 0x66667777,
    0x88889999, 0xAAAABBBB, 0xCCCCDDDD, 0xEEEEFFFF,
    0x00000000, 0x11111111, 0x22222222, 0x33333333,
    0x44444444, 0x55555555, 0x66666666, 0x77777777,
    0x11111111, 0x22222222, 0x44444444, 0x88888888,
    0xAAAAAAAA, 0x55555555, 0x99999999, 0x66666666,
    0xEEEEEEEE, 0x77777777, 0xFFFFFFFF, 0x00000000,
    0x33333333, 0xCCCCCCCC, 0xDEADBEEF, 0xFEEDFACE 
};

#define SPARE_SRAM  0x80006000

/********************************************************************/
void 
main (void)
{
    int result = 0;
    uint32 test;


    sdram_cache_test();
    result |= sdram_test();
    ASSERT(result == 0);
    
    result |= eth_test(0);
    ASSERT(result == 0);
    
    result |= ulpi_test();
    ASSERT(result == 0);
    
    while(1) {
    };
}
/********************************************************************/
void
burst_writes(int dest, int lines)
{
    int i, j;
    
    for (i = 0; i < lines; i+=16)
        mcf5xxx_move_line((ADDRESS)&test_data[0], dest + i);
}
/********************************************************************/
int 
sdram_test (void)
{
	uint32 mem1, mem2, data1, data2;
	int i, fail;

    if (memtest_databus_32((uint32 *)SDRAM_ADDRESS)                   ||
        memtest_databus_32((uint32 *)SDRAM_ADDRESS+1)                 ||
        memtest_databus_32((uint32 *)SDRAM_ADDRESS+2)                 ||
        memtest_databus_32((uint32 *)SDRAM_ADDRESS+3)                 ||
        memtest_databus_32((uint32 *)(SDRAM_ADDRESS+SDRAM_SIZE/2))    ||
        memtest_databus_32((uint32 *)(SDRAM_ADDRESS+SDRAM_SIZE/2)+1)  ||
        memtest_databus_32((uint32 *)(SDRAM_ADDRESS+SDRAM_SIZE/2)+2)  ||
        memtest_databus_32((uint32 *)(SDRAM_ADDRESS+SDRAM_SIZE/2)+3))
        return SDRAM_FAIL;
    
    if (memtest_addrbus_32((uint32 *) (SDRAM_ADDRESS+(SDRAM_SIZE/8*3)), 
                          SDRAM_SIZE/4))
        return SDRAM_FAIL;
        
    if (memtest_device_32((uint32 *) (SDRAM_ADDRESS+(SDRAM_SIZE/16*7)), 
                          SDRAM_SIZE/8))
        return SDRAM_FAIL;

    if (memtest_databus_16((uint16 *)SDRAM_ADDRESS)                   ||
        memtest_databus_16((uint16 *)SDRAM_ADDRESS+1)                 ||
        memtest_databus_16((uint16 *)SDRAM_ADDRESS+2)                 ||
        memtest_databus_16((uint16 *)SDRAM_ADDRESS+3)                 ||
        memtest_databus_16((uint16 *)(SDRAM_ADDRESS+SDRAM_SIZE/2))    ||
        memtest_databus_16((uint16 *)(SDRAM_ADDRESS+SDRAM_SIZE/2)+1)  ||
        memtest_databus_16((uint16 *)(SDRAM_ADDRESS+SDRAM_SIZE/2)+2)  ||
        memtest_databus_16((uint16 *)(SDRAM_ADDRESS+SDRAM_SIZE/2)+3))
        return SDRAM_FAIL;
    
    if (memtest_addrbus_16((uint16 *) (SDRAM_ADDRESS+(SDRAM_SIZE/8*3)), 
                          SDRAM_SIZE/4))
        return SDRAM_FAIL;
        
    if (memtest_device_16((uint16 *) (SDRAM_ADDRESS+(SDRAM_SIZE/16*7)), 
                          SDRAM_SIZE/8))
        return SDRAM_FAIL;

#if 0
    /* Disable bursting on XBS */
    MCF_SCM_BCR = 0;
    
    /* Clear a small portion of SDRAM */
    for (i = 0; i < sizeof(test_data); i+=4)
        *(uint32*)(SDRAM_ADDRESS + i) = 0;
        

    
    /* Move lines of test data into the SDRAM (with bursting disabled) */
    mcf5xxx_move_line((ADDRESS)&test_data[0], SDRAM_ADDRESS + 0);
    mcf5xxx_move_line((ADDRESS)&test_data[4], SDRAM_ADDRESS + 16);
    mcf5xxx_move_line((ADDRESS)&test_data[8], SDRAM_ADDRESS + 32);
    mcf5xxx_move_line((ADDRESS)&test_data[12], SDRAM_ADDRESS + 48);
    mcf5xxx_move_line((ADDRESS)&test_data[16], SDRAM_ADDRESS + 64);
    

    printf("SDRAM contents after line moves with bursting disabled:");
    for (i = 0; i < sizeof(test_data); i+=2)
    {
        if (!(i % 16))
            printf("\n0x%08x:  ", (SDRAM_ADDRESS + i));
        printf("%04x ", *(uint16 *)(SDRAM_ADDRESS + i));
    }
    printf("\n\n");
#endif
#if 1
     
    /* Clear a small portion of SDRAM */
    for (i = 0; i < sizeof(test_data); i+=4)
        *(uint32*)(SDRAM_ADDRESS + i) = 0;
    
    /* burst from SRAM to SRAM */
    /*
    mcf5xxx_move_line((ADDRESS)&test_data[0], SPARE_SRAM + 0);
    mcf5xxx_move_line((ADDRESS)&test_data[4], SPARE_SRAM + 16);
    mcf5xxx_move_line((ADDRESS)&test_data[8], SPARE_SRAM + 32);
    mcf5xxx_move_line((ADDRESS)&test_data[12], SPARE_SRAM + 48);
    mcf5xxx_move_line((ADDRESS)&test_data[16], SPARE_SRAM + 64);
    */
    /* burst from SRAM to SDRAM */
    mcf5xxx_move_line((ADDRESS)&test_data[0], SDRAM_ADDRESS + 0);
    mcf5xxx_move_line((ADDRESS)&test_data[4], SDRAM_ADDRESS + 16);
    mcf5xxx_move_line((ADDRESS)&test_data[8], SDRAM_ADDRESS + 32);
    mcf5xxx_move_line((ADDRESS)&test_data[12], SDRAM_ADDRESS + 48);
    mcf5xxx_move_line((ADDRESS)&test_data[16], SDRAM_ADDRESS + 64);

    /* burst from SDRAM to SRAM */
    /*
    mcf5xxx_move_line((ADDRESS)(SDRAM_ADDRESS + 0), SPARE_SRAM + 0);
    mcf5xxx_move_line((ADDRESS)(SDRAM_ADDRESS + 16), SPARE_SRAM + 16);
    mcf5xxx_move_line((ADDRESS)(SDRAM_ADDRESS + 32), SPARE_SRAM + 32);
    mcf5xxx_move_line((ADDRESS)(SDRAM_ADDRESS + 48), SPARE_SRAM + 48);
    mcf5xxx_move_line((ADDRESS)(SDRAM_ADDRESS + 64), SPARE_SRAM + 64);
    */
    /*
    printf("SDRAM contents after line moves with bursting enabled:");
    for (i = 0; i < sizeof(test_data); i+=2)
    {
        if (!(i % 16))
            printf("\n0x%08x:  ", (SDRAM_ADDRESS + i));
        printf("%04x ", *(uint16 *)(SDRAM_ADDRESS + i));
    }
    printf("\n");
    */
    for (i = 0; i < 80/4; i++)
    {
        if (test_data[i] != *(uint32 *)(SDRAM_ADDRESS + i*4))
            return SDRAM_FAIL;
    }
    
#endif    
#if 0
    /* Page tests */
	for (i = 0; i < SDRAM_SIZE; i+=4)
		*(uint32 *) (SDRAM_ADDRESS + i) = SDRAM_ADDRESS + i;
	
	for (mem1 = SDRAM_ADDRESS; 
     	 mem1 < (SDRAM_ADDRESS + SDRAM_SIZE); 
     	 mem1+=SDRAM_SIZE/4)
	{
	    for(mem2 = SDRAM_ADDRESS; mem2 < SDRAM_ADDRESS + SDRAM_SIZE; mem2 += 0x400)
		{ 
			data1 = *(uint32 *)(mem1);
			data2 = *(uint32 *)(mem2);
	
			if (data1 != mem1)
                return SDRAM_FAIL;
			if (data2 != mem2)
                return SDRAM_FAIL;
		}
	}
#endif
    return SDRAM_PASS;
}
/********************************************************************/
void
sdram_cache_test (void)
{
    int i;
    uint16 temp, *src, *data;
    
    printf("SDRAM/Cache Test\n");
    
    src = (uint16*)(SDRAM_ADDRESS);
    data = (uint16*)test_data;
    
    /* Initialize SDRAM with known data */
    for (i = 0; i < sizeof(test_data)/2; i++)
    {
        src[i] = data[i];
    }
    
    /* Enable bursting in XBS */
    MCF_SCM_BCR = 0
        | MCF_SCM_BCR_GBW
        | MCF_SCM_BCR_GBR
        | 0x00000004;
     
    /* Setup CACR to enable data cache; default mode is inhibited-precise */
    mcf5xxx_wr_cacr(0
        | MCF5XXX_CACR_DEC
        | MCF5XXX_CACR_DDCM_IP
        | MCF5XXX_CACR_DCINVA);
        
    /* First 16MB of SDRAM will be copy-back cacheable */ 
    mcf5xxx_wr_acr0(0
        | MCF5XXX_ACR_AB(SDRAM_ADDRESS)
        | MCF5XXX_ACR_AM_16M
        | MCF5XXX_ACR_EN
        | MCF5XXX_ACR_SM_IGNORE
        | MCF5XXX_ACR_CM_CB);
        
    /*****************************
     * Access at 0x0 aligned address
     */
    temp = *(uint16*)(SDRAM_ADDRESS + 0);
    
    printf("\n0x0 aligned: ");
    for (i = 0; i < 8; i++)
    {
        printf(" %04x", src[i]);
        ASSERT(src[i] == data[i]);
    }
    
    /* Invalidate the data cache */
    mcf5xxx_wr_cacr(0
        | MCF5XXX_CACR_DEC
        | MCF5XXX_CACR_DDCM_IP
        | MCF5XXX_CACR_DCINVA);

    /*****************************
     * Access at 0x4 aligned address
     */
    temp = *(uint16*)(SDRAM_ADDRESS + 4);
    
    printf("\n0x4 aligned: ");
    for (i = 0; i < 8; i++)
    {
        printf(" %04x", src[i]);
        ASSERT(src[i] == data[i]);
    }
    
    /* Invalidate the data cache */
    mcf5xxx_wr_cacr(0
        | MCF5XXX_CACR_DEC
        | MCF5XXX_CACR_DDCM_IP
        | MCF5XXX_CACR_DCINVA);

    /*****************************
     * Access at 0x8 aligned address
     */
    temp = *(uint16*)(SDRAM_ADDRESS + 8);
    
    printf("\n0x8 aligned: ");
    for (i = 0; i < 8; i++)
    {
        printf(" %04x", src[i]);
        ASSERT(src[i] == data[i]);
    }
    
    /* Invalidate the data cache */
    mcf5xxx_wr_cacr(0
        | MCF5XXX_CACR_DEC
        | MCF5XXX_CACR_DDCM_IP
        | MCF5XXX_CACR_DCINVA);

    /*****************************
     * Access at 0xC aligned address
     */
    temp = *(uint16*)(SDRAM_ADDRESS + 12);
    
    printf("\n0xC aligned: ");
    for (i = 0; i < 8; i++)
    {
        printf(" %04x", src[i]);
        ASSERT(src[i] == data[i]);
    }
    printf("\n");
    
    /* Disable and invalidate the data cache */
    mcf5xxx_wr_cacr(MCF5XXX_CACR_DCINVA);       
}
/********************************************************************/