t_sdram.c

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

 * of the top64 bug
 */
start_p = sdram_virt_base + (blkOffset/sizeof(int32)) ;
end_p = (int32 *) (((char *) sdram_virt_base) + sdram_len - 64) ;
errors = 0 ;

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

for ( pass = 0; (errors == 0) && (pass < 100) ; pass++) {

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

	/*
	 * Initialize all memory to zero
	 */
	printf("Pass %d, Initializing Memory\n", pass);

	ipp = sdram_virt_base;
	while (ipp < end_p)
		{
		*ipp++ = 0;
		}
	ipp = start_p;

	while (ipp < end_p)
		{
		obs_val = *ipp ;
		if ( obs_val != 0 )
			{
			MMIO(ICLEAR) = 0;  /* LA Trigger */
			printf("Init error:    addr %08x exp %08x obs %08x xor %08x\n",
				SDRAM_VA_TO_PA(ipp), 0, obs_val, obs_val) ;
			errors++;
			}
		ipp++ ;
		}

	if ( errors >= errors_max )
		{
		break;
		}

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

	/*
	 * Write/verify data patterns on block by block basis
	 */
	printf("Write/Verify Memory\n");

	blk_p = start_p ;
	while (errors == 0)
		{
		/*
		 * Set last location to test
		 * (and make sure we don't overrun end of region)
		 */
		blk_end_p = blk_p + (blkSize/sizeof(int32)) ;
		if (blk_end_p >= end_p)
			{
			last_p = blk_p ;
			break ;
			}

		/*
		 * Write data
		 */
		ipp = blk_p ;
		exp_val = SDRAM_VA_TO_PA(ipp) ;
		while (ipp < blk_end_p)
			{
			*ipp++ = exp_val ;
			exp_val += sizeof(int32) ;
			}

		/*
		 * Verify data
		 */
		ipp = blk_p ;
		exp_val = SDRAM_VA_TO_PA(ipp) ;
		while (ipp < blk_end_p)
			{
			obs_val = *ipp ;
			if (obs_val != exp_val)
				{
				errors++ ;
				MMIO(ICLEAR) = 0;  /* LA Trigger */
				printf("verify error:    addr %08x exp %08x obs %08x xor %08x\n",
					exp_val, exp_val, obs_val, exp_val ^ obs_val) ;
				break;
				}
			ipp++ ;
			exp_val += sizeof(int32) ;
			}

		/*
		 * Increment block pointer
		 */
		blk_p += (blkSize/sizeof(int32)) ;
		}

	if ( errors >= errors_max )
		{
		break;
		}

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

	/*
	 * Final pass through memory to make sure
 	 * no writes were misplaced
	 *
	 * Note that this requires three loops:
	 *	test zeroes before first block
	 *	test addr@addr for blocks
	 *	test zeroes after last block
	 */
	printf("Reading Memory\n");

	ipp = sdram_virt_base ;
	while ((errors == 0) && (ipp < start_p))
		{
		obs_val = *ipp ;
		if (obs_val != 0)
			{
			MMIO(ICLEAR) = 0;  /* LA Trigger */
			errors++ ;
			printf("read error    addr %08x exp %08x obs %08x xor %08x\n",
				SDRAM_VA_TO_PA(ipp), 0, obs_val, obs_val) ;
			break;
			}
		ipp++ ;
		}

	exp_val = SDRAM_VA_TO_PA(ipp) ;
	while ((errors == 0) && (ipp < last_p))
		{
		obs_val = *ipp ;
		if (obs_val != exp_val)
			{
			MMIO(ICLEAR) = 0;  /* LA Trigger */
			errors++ ;
			printf("read error    addr %08x exp %08x obs %08x xor %08x\n",
				exp_val, exp_val, obs_val, exp_val ^ obs_val) ;
			break;
			}
		ipp++ ;
		exp_val += sizeof(int32) ;
		}

	while ((errors == 0) && (ipp < end_p))
		{
		obs_val = *ipp ;
		if (obs_val != 0)
			{
			MMIO(ICLEAR) = 0;  /* LA Trigger */
			errors++ ;
			printf("read error    addr %08x exp %08x obs %08x xor %08x\n",
				SDRAM_VA_TO_PA(ipp), 0, obs_val, obs_val) ;
			break;
			}
		ipp++ ;
		}
	}

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

return errors;
}

/*----------------------------------------------------------------------
 * 32 bit aligned x86 to sdram burst mode stress test
 */
int
burst32(
int32	burst_bytes,
int32	offset_bytes,
int	pass_max
)
{
int32		*region_start ;
int32		*region_end ;
int32		*blk_start ;
int32		*blk_end ;
int32		*preload_start ;
int32		*preload_end ;
int32		exp_blk ;
int32		exp_preload ;
int		errors ;
int		pass ;
int		report ;
int		report_interval ;
int32		biu_cntl_save ;
int32		biu_cntl_burst_on ;
int32		biu_cntl_burst_off ;

errors = 0 ;

printf("x86 to sdram burst write test. burst_bytes 0x%x burst_offset 0x%x pass_max 0x%x\n", 
	   burst_bytes, offset_bytes, pass_max) ;

/*
 * setup test boundaries
 *
 */
region_start = sdram_virt_base + ((sdram_len/2)/sizeof(int32)) ;
region_end = region_start + (256/sizeof(int32)) ;
preload_start = region_start + ((sdram_len/4)/sizeof(int32)) ;
preload_end = preload_start + (64/sizeof(int32)) ;
blk_start = region_start + (64/sizeof(int32)) + (offset_bytes/sizeof(int32)) ;
blk_end = blk_start + (burst_bytes/sizeof(int32)) ;

exp_blk = 0x40000000 | (((int32) SDRAM_VA_TO_PA(blk_start)) & 0xff) ;
exp_preload = 0x80000000 | (((int32) SDRAM_VA_TO_PA(preload_start)) & 0xff) ;

printf("burst mode test, 32 bit aligned\n") ;
printf("    region  %08x %08x\n",
	SDRAM_VA_TO_PA(region_start),
	SDRAM_VA_TO_PA(region_end)) ;
printf("    preload %08x %08x\n", 
	SDRAM_VA_TO_PA(preload_start),
	SDRAM_VA_TO_PA(preload_end)) ;
printf("    blk     %08x %08x\n", 
	SDRAM_VA_TO_PA(blk_start),
	SDRAM_VA_TO_PA(blk_end)) ;

errors = 0 ;

/*
 * Save current burst mode
 */
biu_cntl_save = MMIO(BIU_CNTL) ;
biu_cntl_burst_on = biu_cntl_save & ~0x2 ;
biu_cntl_burst_off = biu_cntl_save | 0x2 ;

report_interval = pass_max / 100 ;
report = report_interval ;
pass = 0 ;
while ((errors == 0) && (pass < pass_max))
	{
	/*
	 * Disable burst mode
	 */
	MMIO(BIU_CNTL) = biu_cntl_burst_off ;

	/*
	 * Initialize region to 0
	 */
	errors += fill_verify32("region init", region_start, region_end,
				0, 0) ;
	if ( errors >= errors_max )
		{
		break;
		}

	/*
	 * Initialize preload to pattern
	 */
	errors += fill_verify32("preload init", preload_start, preload_end,
				exp_preload, sizeof(int32)) ;
	if ( errors >= errors_max )
		{
		break;
		}

	/*
	 * Write/verify data patterns on block by block basis
	 */
	MMIO(BIU_CNTL) = biu_cntl_burst_on ;
	errors += fill_verify32("block test", blk_start, blk_end,
				exp_blk, sizeof(int32)) ;
	MMIO(BIU_CNTL) = biu_cntl_burst_off ;
	if ( errors >= errors_max )
		{
		break;
		}

	/*
	 * Final pass through memory to make sure
 	 * no writes were misplaced
	 *
	 * Note that this requires three loops:
	 *	test zeroes before first block
	 *	test addr@addr for blocks
	 *	test zeroes after last block
	 */
	errors += verify32("preload final", preload_start, preload_end,
				exp_preload, sizeof(int32)) ;
	if ( errors >= errors_max )
		{
		break;
		}
	errors += verify32("region_low", region_start, blk_start, 0, 0) ;
	if ( errors >= errors_max )
		{
		break;
		}
	errors += verify32("block final", blk_start, blk_end,
				exp_blk, sizeof(int32)) ;
	if ( errors >= errors_max )
		{
		break;
		}
	errors += verify32("region_high", blk_end, region_end, 0, 0) ;
	if ( errors >= errors_max )
		{
		break;
		}

	/*
	 * pass reporting
	 */
	if (report == 0)
		{
		printf("    pass %10d errors %10d\r", pass, errors) ;
		report = report_interval ;
		}
	report-- ;
	pass++ ;
	}
printf("    burst32 done - pass %10d errors %10d\n", pass, errors) ;

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

return errors;
}

/*----------------------------------------------------------------------
 * Fill and verify 32 bit aligned region
 */

int
fill_verify32(
char	*name,
int32	*start_p,
int32	*end_p,
int32	exp_start,
int32	exp_increment
)

{
fill32(name, start_p, end_p, exp_start, exp_increment) ;
return verify32(name, start_p, end_p, exp_start, exp_increment) ;
}

/*----------------------------------------------------------------------
 * Fill 32 bit aligned region
 */

void
fill32(
char	*name,
int32	*start_p,
int32	*end_p,
int32	exp_start,
int32	exp_increment
)

{
int32	*ipp ;
int32	exp_val ;

if (trace) printf("    filling %s from %08x to %08x, pattern %08x increment %08x\n",
		name, 
		SDRAM_VA_TO_PA(start_p),
		SDRAM_VA_TO_PA(end_p),
		exp_start,
		exp_increment);

ipp = start_p ;
exp_val = exp_start ;
while (ipp < end_p)
	{
	*ipp++ = exp_val ;
	exp_val += exp_increment ;
	}
}

/*----------------------------------------------------------------------
 * Verify 32 bit aligned region
 */

int
verify32(
char	*name,
int32	*start_p,
int32	*end_p,
int32	exp_start,
int32	exp_increment
)

{
int32	*ipp ;
int32	exp_val ;
int32	obs_val ;
int	errors ;

if (trace) printf("    verifying %s from %08x to %08x, pattern %08x increment %08x\n",
		name, 
		SDRAM_VA_TO_PA(start_p),
		SDRAM_VA_TO_PA(end_p),
		exp_start,
		exp_increment);

errors = 0 ;
ipp = start_p;
exp_val = exp_start ;
while ((errors < errors_max) && (ipp < end_p))
	{
	obs_val = *ipp ;
	if ( obs_val != exp_val )
		{
		MMIO(ICLEAR) = 0;  /* LA Trigger */
		errors++;
		printf("Error %s:    addr %08x exp %08x obs %08x xor %08x\n",
			name,
			SDRAM_VA_TO_PA(ipp),
			exp_val, obs_val, exp_val ^ obs_val) ;
		obs_val = *ipp ;
		if ( obs_val != exp_val )
			{
			printf("Error %s:    addr %08x exp %08x obs %08x xor %08x\n",
				name,
				SDRAM_VA_TO_PA(ipp),
				exp_val, obs_val, exp_val ^ obs_val) ;
			}
		}
	ipp++ ;
	exp_val += exp_increment ;
	}
return errors ;
}

/*----------------------------------------------------------------------*/