memtest.c

detailed memory test for embedded systems, checks for shorted address/data lines too

/**@file memset.c
 ************************************************************************************
 *	Name	: memtest.c																*
 *	Purpose	: Library for testing memory											*
 *																					*
 *	Author	: Vijay Vikrant Balyan													*
 ************************************************************************************/

/** Includes */
#include<stdio.h>
#include<stdlib.h>

/** Defines */
#define PAT_PLAIN	0	/* Fixed pattern all across the memory*/
#define PAT_INCR	1	/* incremental pattern - helps to catch address bus shorts */
#define PAT_XOR		2	/* helps to detect the horizontally and vertically shorted lines */

/* checker board
   0xAAAAAAAA, 0x55555555,
   0xAAAAAAAA, 0x55555555,
   0xAAAAAAAA, 0x55555555,
   0xAAAAAAAA, 0x55555555,
 */

/* inverted checker board 
   0x55555555, 0xAAAAAAAA,
   0x55555555, 0xAAAAAAAA,
   0x55555555, 0xAAAAAAAA,
   0x55555555, 0xAAAAAAAA,
 */

//#define MEM_SIZE	(16 * 1024 * 1024)
#define MEM_SIZE	(64)

/** Function prototypes */
int memtest_trigger();
int memtest_fill(unsigned int *p, unsigned int pat, unsigned int flag, unsigned int size);
int memtest_verify(unsigned int *p, unsigned int pat, unsigned int flag, unsigned int size);

/* Functions */
int main()
{
		memtest_trigger();
		return 0;
}

unsigned char * memtest_flag_return(unsigned int flag)
{
		switch (flag)
		{
				case PAT_PLAIN:
						return "PAT_PLAIN";

				case PAT_INCR:
						return "PAT_INCR";

				case PAT_XOR:
						return "PAT_XOR";
		}
		return "NULL";
}

int printmem(unsigned int *p, int size)
{
	/* prints all the buffer, delimited by the size specified */
	int i,j;

	for (i = 0; i < (size >> 4) ; i++)
	{
		printf("\r\n");
		for (j = 0; j < 8; j++)
			printf ("%08X ", p[(i * 8) + j]);
	}
		printf("\r\n");

return 0;
}

int memtest_trigger()
{
		unsigned int *p;
		unsigned int pat, flag, i;

		typedef struct
		{
				unsigned char *name;
				unsigned int pat;
				unsigned int flag;
		}param_t;

		param_t param[6] = {
				{"ALL_ZERO", 0x00000000, PAT_PLAIN}, {"ALL_F", 0xFFFFFFFF, PAT_PLAIN},
				{"ALL_FIVE", 0x55555555, PAT_PLAIN}, {"ALL_A", 0xAAAAAAAA, PAT_PLAIN},
				{"Checker Board", 0xAAAAAAAA, PAT_XOR},
				{"Linear Increment", 0x00000000, PAT_INCR}
		};

		p = malloc (sizeof(unsigned int) * MEM_SIZE);

		for (i = 0; i < (sizeof(param)/sizeof(param_t)); i++)
		{
				printf("pattern [%16s] flag [%9s]  ", param[i].name , memtest_flag_return(param[i].flag));
				pat = param[i].pat;
				flag = param[i].flag;

				printf("Filling ... ");
				memtest_fill(p, pat, flag, MEM_SIZE);

				printf("Verifying ... ");
				memtest_verify(p, pat, flag, MEM_SIZE);
		}


		return 0;
}

int memtest_fill(unsigned int *p, unsigned int pat, unsigned int flag, unsigned int size)
{
		int i;
		for (i = 0; i < size; i ++)
		{
				if (flag == PAT_PLAIN)
				{
						p[i] = pat;
				}
				else if (flag == PAT_INCR)
				{
						p[i] = pat++;
				}
				else if (flag == PAT_XOR)
				{
						if (i%2 == 0)
								p[i] = pat;
						else
								p[i] = ~pat;
				}

		}
		return 0;
}

int memtest_verify(unsigned int *p, unsigned int pat, unsigned int flag, unsigned int size)
{
		int i, error = 0;

		for (i = 0; i < size; i++)
		{
				if (flag == PAT_PLAIN)
				{
						if (p[i] != pat)
						{
								printf("MEMORY ERROR DETCETED \r\n");
								error = 1;
						}
				}
				else if(flag == PAT_INCR)
				{
						if (p[i] != pat++)
						{
								printf("MEMORY ERROR DETCETED \r\n");
								error = 1;
						}
				}
				else if (flag == PAT_XOR)
				{
						if (i%2 == 0)
						{
								if (p[i] != pat)
								{
										printf("MEMORY ERROR DETCETED \r\n");
										error = 1;
								}
						}
						else
						{
								if (p[i] != (~pat))
								{
										printf("MEMORY ERROR DETCETED \r\n");
										error = 1;
								}
						}
				}
		}
		if (!error)
				printf("mem ok\r\n");
		return 0;
}