t_sdram.c

PNX系列设备驱动 PNX系列设备驱动

static char sccs_id[] = "@(#)t_sdram.c	1.5 3/26/96 10:47:59" ;
/*
 * t_sdram.c
 * sdram tests
 */

#include <stdio.h>
#include <stdlib.h>
#include "hwdefs.h"
#include "testvars.h"
#include "mmio.h"
#include "mreg.h"
#include "t_sdram.h"

#define SDRAM_VA_TO_PA(ipp)	(sdram_phys_base + (sizeof(int32)*((ipp) - sdram_virt_base)))

static	int	trace = 0 ;
static	int	errors_max = 100 ;

/*
 * local function declarations
 */
int	block_test(int, int) ;
int	burst32(int32, int32, int) ;
int	fill_verify32(char *, int32 *, int32 *, int32, int32) ;
void	fill32(char *, int32 *, int32 *, int32, int32) ;
int	verify32(char *, int32 *, int32 *, int32, int32) ;

/*----------------------------------------------------------------------
 * Test sdram by storing address at address
 */
int
t_sdram_addr()
{
int32	*end_p ;
int32	*ipp ;
int32	exp_val ;
int32	obs_val ;
int	errors ;

printf("sdram address test\n") ;

end_p = (int32 *) (((char *) sdram_virt_base) + sdram_len) ;
errors = 0 ;

/*
 * Fill memory with data==address
 */
ipp = sdram_virt_base ;
while (ipp < end_p)
	{
	exp_val = (int32) ipp ;
	*ipp++ = exp_val ;
	}

/*
 * Check memory with data==address
 */
ipp = sdram_virt_base ;
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) ;
		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 by storing 1's complement of address at address
 */
int
t_sdram_inv_addr()
{
int32	*end_p ;
int32	*ipp ;
int32	exp_val ;
int32	obs_val ;
int	errors ;

printf("sdram inverse address test\n") ;

end_p = (int32 *) (((char *) sdram_virt_base) + sdram_len) ;
errors = 0 ;

/*
 * Fill memory with data==~address
 */
ipp = sdram_virt_base ;
while (ipp < end_p)
	{
	exp_val = (~((int32) ipp)) ;
	*ipp++ = exp_val ;
	}

/*
 * Check memory with data==~address
 */
ipp = sdram_virt_base ;
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) ;
		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	*end_p ;
int32	*ipp ;
int32	start_val ;
int32	exp_val ;
int32	obs_val ;
int	lap ;
int	errors ;

printf("sdram walking ones test\n") ;

end_p = (int32 *) (((char *) sdram_virt_base) + sdram_len) ;
errors = 0 ;

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

	/*
	 * Fill memory with data
	 */
	exp_val = start_val ;
	ipp = sdram_virt_base ;
	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 = sdram_virt_base ;
	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) ;
			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	*end_p ;
int32	*ipp ;
int32	start_val ;
int32	loop_val ;
int32	exp_val ;
int32	obs_val ;
int	errors ;
int	lap ;

printf("sdram walking zeroes test\n") ;

end_p = (int32 *) (((char *) sdram_virt_base) + sdram_len) ;
errors = 0 ;

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

	/*
	 * Fill memory with data
	 */
	loop_val = start_val ;
	ipp = sdram_virt_base ;
	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 = sdram_virt_base ;
	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) ;
			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 ;
}

/*----------------------------------------------------------------------
 * Demonstrate top 64 byte bad read problem
 */
int
t_sdram_top64()
{
int32	*end_p ;
int32	*ipp ;
int32	obs_val ;
int32	*start_p ;
int32	biu_cntl_save ;
int	errors ;
int	pass ;

errors = 0 ;

printf("sdram top 64 byte bug test.\n") ;

/*
 * setup boundary pointers
 */
end_p = (int32 *) (((char *) sdram_virt_base) + sdram_len) ;
start_p = (int32 *) (((char *) end_p) - 64) ;

/*
 * Save current burst mode
 */
biu_cntl_save = MMIO(BIU_CNTL) ;

/*
 * Disable burst mode
 */
MMIO(BIU_CNTL) = biu_cntl_save | 0x2 ;

/*
 * Initialize top 64 bytes to 0
 */
printf("Initializing Memory\n");
ipp = start_p ;
while (ipp < end_p)
	{
	*ipp++ = 0 ;
	}

/*
 * Loop until we see an error
 */
for ( pass = 0; (errors == 0) && (pass < 1000000) ; pass++) {

	/*
	 * Print pass count every 100 passes
	 */
	if ((pass % 10000) == 0)
		{
		printf("Pass %d, Verifying Memory\r", pass);
		}

	/*
	 * Verify memory
	 */
	ipp = start_p;
	while (ipp < end_p)
		{
		obs_val = *ipp ;
		if ( obs_val != 0 )
			{
			MMIO(ICLEAR) = 0;  /* LA Trigger */
			printf("Pass %-5d addr %08x exp %08x obs %08x xor %08x\n",
				pass,
				SDRAM_VA_TO_PA(ipp),
				0,
				obs_val,
				obs_val) ;
			errors++;
			}
		ipp++ ;
		}
	}

/*
 * Restore old burst mode
 */
MMIO(BIU_CNTL) = biu_cntl_save ;

return errors;
}

/*----------------------------------------------------------------------
 * sdram write/verify with 64 byte blocks, 0 byte offset
 */
int
t_sdram_block64_offset0()
{
return block_test(64, 0) ;
}

/*----------------------------------------------------------------------
 * sdram write/verify with 64 byte blocks, 4 byte offset
 */
int
t_sdram_block64_offset4()
{
return block_test(64, 4) ;
}

/*----------------------------------------------------------------------
 * sdram write/verify with 64 byte blocks, 4 byte offset
 */
int
t_sdram_burst()
{
int32	burst_bytes ;
int32	offset_bytes ;
int	pass_max ;

if (test_argc != 4)
	{
	printf("usage: sdram_burst <burst_bytes> <offset_bytes> <max_passes>\n") ;
	return 1 ;
	}
burst_bytes = strtol(test_argv[1], NULL, 16) ;
offset_bytes = strtol(test_argv[2], NULL, 16) ;
pass_max = strtol(test_argv[3], NULL, 10) ;

if ((burst_bytes & 3) != 0)
	{
	printf("burst_bytes 0x%x must be word aligned\n", burst_bytes) ;
	return 1 ;
	}

if ((offset_bytes & 3) != 0)
	{
	printf("offset_bytes 0x%x must be word aligned\n", offset_bytes) ;
	return 1 ;
	}
return burst32(burst_bytes, offset_bytes, pass_max) ;
}

/*----------------------------------------------------------------------
 * sdram write/verify with arbitrary block size and offset
 */
int
block_test(
int	blkSize,
int	blkOffset
)
{
int32		*start_p ;
int32		*end_p ;
int32		*blk_p ;
int32		*blk_end_p ;
int32		*last_p ;
int32		*ipp ;
int32		exp_val ;
int32		obs_val ;
int		errors ;
int		pass ;
int32		biu_cntl_save ;

errors = 0 ;

printf("sdram block read/write test. Block Size %d Block Offset %d\n", 
	   blkSize, blkOffset) ;

/*
 * setup test boundaries
 *
 * Note we avoid the last 64 byte region because