sdram_test.c

pnx1500 ddr test demo

/*
 * sdram_tst.c
 * Verify sdram is functioning
 */
#include <stdio.h>
#include <stdlib.h>
#include <tm1/mmio.h>
#include <tmlib/tmtypes.h>
#include <ops/custom_defs.h>

#include "tm_common.h"

#define DBG(a,b) pci_mem_write32(0x40000000+(a), (b))

#define TRUE 1
#define FALSE 0

int sdram_fail;
int StressSdram;

t_sdram_flipbits(unsigned value, unsigned *start, unsigned len)      /* 64 byte aligned guarranteed */
{
    unsigned *p, v, i, obs, err;

    err = 0;

    p = start;
    v = value;

    for(i = 0; i < (len/sizeof(unsigned)); p++, i++) {
        *p = v;
        v = ~v;
    }


    p = start;
    v = value;

    for(i = 0; i < (len/sizeof(unsigned)); p++, i++) {
        if((obs = *p) != v) {

            err++;
            printf("Read error:    @ 0x%.8x, obs 0x%.8x, exp 0x%.8x, obs ^ exp 0x%.8x\n",
                   (unsigned)(p), obs, v, obs ^ v);

            INVALIDATE(p, 1);

            if((obs = *p) != v) {
                printf("Re-Read error: @ 0x%.8x, obs 0x%.8x, exp 0x%.8x, obs ^ exp 0x%.8x\n",
                       (unsigned)(p), obs, v, obs ^ v);
            }
        }

        v = ~v;
    }

    return err;
}




/*
 * Test sdram by storing address at address
 */
int
   t_sdram_addr(
                Int32   *mmio_base,
                Int32   *begin_p,
                Int32   len
               )
{
    Int32   *end_p ;
    Int32   *ipp ;
    Int32   exp_val ;
    Int32   obs_val ;
    int errors ;

    end_p = (Int32 *) (((char *) begin_p) + len) ;
    errors = 0 ;

/*
 * Fill memory with data==address
 */
    ipp = begin_p ;
    while (ipp < end_p)
    {
        *ipp = (Int32) ipp ;
        ipp++;
    }

/*
 * Check memory with data==address
 */
    ipp = begin_p ;
    while (ipp < end_p)
    {
        exp_val = (Int32) ipp ;
        obs_val = *ipp ;
        if (obs_val != exp_val)
        {
            errors++ ;
            printf("read error:    addr %08x exp %08x obs %08x xor %08x\n",
                   ipp, exp_val, obs_val, exp_val ^ obs_val) ;
            INVALIDATE(ipp,1);
            obs_val = *ipp ;
            if (obs_val != exp_val)
            {
                printf("re-read error: addr %08x exp %08x obs %08x xor %08x\n",
                       ipp, exp_val, obs_val, exp_val ^ obs_val) ;
            }
            if (errors > 5)
            {
                printf("errors > 5, exitting...\n") ;
                exit(errors) ;
            }
        }
        ipp++ ;
    }

    return errors ;
}

/*
 * Test sdram by storing 1's complement of address at address
 */
int
   t_sdram_inv_addr(
                    Int32   *mmio_base,
                    Int32   *begin_p,
                    Int32   len
                   )
{
    Int32   *end_p ;
    Int32   *ipp ;
    Int32   exp_val ;
    Int32   obs_val ;
    int errors ;

    end_p = (Int32 *) (((char *) begin_p) + len) ;
    errors = 0 ;

/*
 * Fill memory with data==~address
 */
    ipp = begin_p ;
    while (ipp < end_p)
    {
        *ipp = (~((Int32) ipp)) ;
        ipp++;
    }

/*
 * Check memory with data==~address
 */
    ipp = begin_p ;
    while (ipp < end_p)
    {
        exp_val = (~((Int32) ipp)) ;
        obs_val = *ipp ;
        if (obs_val != exp_val)
        {
            errors++ ;
            printf("read error:    addr %08x exp %08x obs %08x xor %08x\n",
                   ipp, exp_val, obs_val, exp_val ^ obs_val) ;
            INVALIDATE(ipp,1);
            obs_val = *ipp ;
            if (obs_val != exp_val)
            {
                printf("re-read error: addr %08x exp %08x obs %08x xor %08x\n",
                       ipp, exp_val, obs_val, exp_val ^ obs_val) ;
            }
        }
        ipp++ ;
    }

    return errors ;
}

/*
 * Test sdram with walking ones
 */
int
   t_sdram_walk1(
                 Int32   *mmio_base,
                 Int32   *begin_p,
                 Int32   len
                )
{
    Int32   *end_p ;
    Int32   *ipp ;
    Int32   start_val ;
    Int32   exp_val ;
    Int32   obs_val ;
    int lap ;
    int errors ;

    end_p = (Int32 *) (((char *) begin_p) + len) ;
    errors = 0 ;

    lap = 0 ;
    start_val = 1 ;
    while (start_val != 0)
    {
        printf("    lap %2d\n", lap++) ;

    /*
     * Fill memory with data
     */
        exp_val = start_val ;
        ipp = begin_p ;
        while (ipp < end_p)
        {
            *ipp++ = exp_val ;
            exp_val = exp_val << 1 ;
            if (exp_val == 0)
            {
                exp_val = 1 ;
            }
        }

    /*
     * Check memory
     */
        exp_val = start_val ;
        ipp = begin_p ;
        while (ipp < end_p)
        {
            obs_val = *ipp ;
            if (obs_val != exp_val)
            {
                errors++ ;
                printf("read error:    addr %08x exp %08x obs %08x xor %08x\n",
                       ipp, exp_val, obs_val, exp_val ^ obs_val) ;
                INVALIDATE(ipp,1);
                obs_val = *ipp ;
                if (obs_val != exp_val)
                {
                    printf("re-read error: addr %08x exp %08x obs %08x xor %08x\n",
                           ipp, exp_val, obs_val, exp_val ^ obs_val) ;
                }
            }
            exp_val = exp_val << 1 ;
            if (exp_val == 0)
            {
                exp_val = 1 ;
            }
            ipp++ ;
        }

        start_val = start_val << 1 ;
    }

    return errors ;
}

/*
 * Test sdram with walking zeroes
 */
int
   t_sdram_walk0(
                 Int32   *mmio_base,
                 Int32   *begin_p,
                 Int32   len
                )
{
    Int32   *end_p ;
    Int32   *ipp ;
    Int32   start_val ;
    Int32   loop_val ;
    Int32   exp_val ;
    Int32   obs_val ;
    int errors ;
    int lap ;

    end_p = (Int32 *) (((char *) begin_p) + len) ;
    errors = 0 ;

    lap = 0 ;
    start_val = 1 ;
    while (start_val != 0)
    {
        printf("    lap %2d\n", lap++) ;

    /*
     * Fill memory with data
     */
        loop_val = start_val ;
        ipp = begin_p ;
        while (ipp < end_p)
        {
            exp_val = ~loop_val ;
            *ipp++ = exp_val ;
            loop_val = loop_val << 1 ;
            if (loop_val == 0)
            {
                loop_val = 1 ;
            }
        }

    /*
     * Check memory
     */
        loop_val = start_val ;
        ipp = begin_p ;
        while (ipp < end_p)
        {
            exp_val = ~loop_val ;
            obs_val = *ipp ;
            if (obs_val != exp_val)
            {
                errors++ ;
                printf("read error:    addr %08x exp %08x obs %08x xor %08x\n",
                       ipp, exp_val, obs_val, exp_val ^ obs_val) ;
                INVALIDATE(ipp,1);
                obs_val = *ipp ;
                if (obs_val != exp_val)
                {
                    printf("re-read error: addr %08x exp %08x obs %08x xor %08x\n",
                           ipp, exp_val, obs_val, exp_val ^ obs_val) ;
                }
            }
            loop_val = loop_val << 1 ;
            if (loop_val == 0)
            {
                loop_val = 1 ;
            }
            ipp++ ;
        }

        start_val = start_val << 1 ;
    }

    return errors ;
}

static unsigned int GetMaxAvailableSize(void)
{
    char            *pBlock ;
    unsigned int            Size ;
    unsigned int            Span ;

    /*
     * Binary search for maximum block size
     */
    Size = 0x40000000 ;
    Span = Size >> 1 ;
    while (Span != 0)
    {
        pBlock = malloc(Size) ;
        if (pBlock == NULL)
        {
            Size -= Span ;
        }
        else
        {
            free(pBlock) ;
            Size += Span ;
        }
        Span = Span >> 1 ;
    }

    return Size ;
}

int main(
         int argc,
         char    *argv[]
        )
{
    int i;
    unsigned int maxblock;
    static Int32 *start;
    static Int32 len;
    static int   first = 1;

	Init_Stdio();
	
	maxblock = GetMaxAvailableSize();
	printf("Maximum available block is %d (0x%08X) bytes.\n",maxblock,maxblock);

    if(first) {
        first = 0;
        len   = (maxblock & ~63);
        start = (Int32 *) malloc(len) ;

        start = (Int32 *)((((unsigned)(start)) + 128) & ~63);    /* Align start to 64 bytes */
        len -= 256;                                         /* Safety                  */


        if(start == NULL) {
            printf("malloc failed\n");
            return 1;
        }
        else printf("SDRAM TEST: Got %d Kbytes, from 0x%.8x to 0x%.8x\n",
                    len/1024, (Int32)(start), ((Int32)(start)+len));
    }

    sdram_fail = t_sdram_addr(0, start, len);
    printf("sdram_addr             %s\n", sdram_fail ? "FAILED" : "passed");
    if (sdram_fail) return(TRUE);
    sdram_fail = t_sdram_inv_addr(0, start, len);
    printf("sdram_inv_addr         %s\n", sdram_fail ? "FAILED" : "passed");
    if (sdram_fail) return(TRUE);


    i = 1;
    do { int j, loops;

    loops = StressSdram ? 8 : 1;

    for(j = 0; j <  loops; j++)
        sdram_fail |= t_sdram_flipbits(0x5A5A5A5A, (unsigned *)start, len);
    printf("sdram_flip 0x5A5A5A5A  %s\n", sdram_fail ? "FAILED" : "passed");
    if(sdram_fail) return TRUE;

    for(j = 0; j <  loops; j++)
        sdram_fail |= t_sdram_flipbits(0x00000000, (unsigned *)start, len);
    printf("sdram_flip 0x00000000  %s\n", sdram_fail ? "FAILED" : "passed");
    if(sdram_fail) return TRUE;
    } while(StressSdram >= i++);

    sdram_fail = t_sdram_walk1(0, start, len);
    printf("sdram_walk1            %s\n", sdram_fail ? "FAILED" : "passed");
    if (sdram_fail) return(TRUE);
    sdram_fail = t_sdram_walk0(0, start, len);
    printf("sdram_walk0            %s\n", sdram_fail ? "FAILED" : "passed");
    if (sdram_fail) return(TRUE);

    return FALSE;
}