V3s_Allwinner
/
uboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

sandbox: Update mtest to fix crashes 

Use map_sysmem() in the memory tester so that it works as expected on
sandbox.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2013-02-28 17:47:14 +00:00
parent 8e169cc943
commit 5512d5b034
1 changed files with 63 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
common/cmd_mem.c
View File

@ -631,21 +631,19 @@ int do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
} }
#endif /* CONFIG_LOOPW */ #endif /* CONFIG_LOOPW */
static ulong mem_test_alt(ulong start_addr, ulong end_addr) static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
vu_long *dummy)
{ {
vu_long *start, *end;
vu_long *addr; vu_long *addr;
ulong errs = 0; ulong errs = 0;
ulong val, readback; ulong val, readback;
int j; int j;
vu_long len;
vu_long offset; vu_long offset;
vu_long test_offset; vu_long test_offset;
vu_long pattern; vu_long pattern;
vu_long temp; vu_long temp;
vu_long anti_pattern; vu_long anti_pattern;
vu_long num_words; vu_long num_words;
vu_long *dummy = (vu_long *)CONFIG_SYS_MEMTEST_SCRATCH;
static const ulong bitpattern[] = { static const ulong bitpattern[] = {
0x00000001, /* single bit */ 0x00000001, /* single bit */
0x00000003, /* two adjacent bits */ 0x00000003, /* two adjacent bits */
@ -657,8 +655,7 @@ static ulong mem_test_alt(ulong start_addr, ulong end_addr)
0xaaaaaaaa, /* alternating 1/0 */ 0xaaaaaaaa, /* alternating 1/0 */
}; };
start = (vu_long *)start_addr; num_words = (end_addr - start_addr) / sizeof(vu_long);
end = (vu_long *)end_addr;
/* /*
* Data line test: write a pattern to the first * Data line test: write a pattern to the first
@ -677,11 +674,11 @@ static ulong mem_test_alt(ulong start_addr, ulong end_addr)
* '0's and '0' bits through a field of '1's (i.e. * '0's and '0' bits through a field of '1's (i.e.
* pattern and ~pattern). * pattern and ~pattern).
*/ */
addr = start; addr = buf;
for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) { for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) {
val = bitpattern[j]; val = bitpattern[j];
for (; val != 0; val <<= 1) { for (; val != 0; val <<= 1) {
*addr = val; *addr = val;
*dummy = ~val; /* clear the test data off the bus */ *dummy = ~val; /* clear the test data off the bus */
readback = *addr; readback = *addr;
if (readback != val) { if (readback != val) {
@ -740,58 +737,56 @@ static ulong mem_test_alt(ulong start_addr, ulong end_addr)
* *
* Returns: 0 if the test succeeds, 1 if the test fails. * Returns: 0 if the test succeeds, 1 if the test fails.
*/ */
len = (end_addr - start_addr) / sizeof(vu_long);
pattern = (vu_long) 0xaaaaaaaa; pattern = (vu_long) 0xaaaaaaaa;
anti_pattern = (vu_long) 0x55555555; anti_pattern = (vu_long) 0x55555555;
debug("%s:%d: length = 0x%.8lx\n", debug("%s:%d: length = 0x%.8lx\n", __func__, __LINE__, num_words);
__func__, __LINE__, len);
/* /*
* Write the default pattern at each of the * Write the default pattern at each of the
* power-of-two offsets. * power-of-two offsets.
*/ */
for (offset = 1; offset < len; offset <<= 1) for (offset = 1; offset < num_words; offset <<= 1)
start[offset] = pattern; addr[offset] = pattern;
/* /*
* Check for address bits stuck high. * Check for address bits stuck high.
*/ */
test_offset = 0; test_offset = 0;
start[test_offset] = anti_pattern; addr[test_offset] = anti_pattern;
for (offset = 1; offset < len; offset <<= 1) { for (offset = 1; offset < num_words; offset <<= 1) {
temp = start[offset]; temp = addr[offset];
if (temp != pattern) { if (temp != pattern) {
printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:" printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx\n", " expected 0x%.8lx, actual 0x%.8lx\n",
(ulong)&start[offset], pattern, temp); start_addr + offset, pattern, temp);
errs++; errs++;
if (ctrlc()) if (ctrlc())
return -1; return -1;
} }
} }
start[test_offset] = pattern; addr[test_offset] = pattern;
WATCHDOG_RESET(); WATCHDOG_RESET();
/* /*
* Check for addr bits stuck low or shorted. * Check for addr bits stuck low or shorted.
*/ */
for (test_offset = 1; test_offset < len; test_offset <<= 1) { for (test_offset = 1; test_offset < num_words; test_offset <<= 1) {
start[test_offset] = anti_pattern; addr[test_offset] = anti_pattern;
for (offset = 1; offset < len; offset <<= 1) { for (offset = 1; offset < num_words; offset <<= 1) {
temp = start[offset]; temp = addr[offset];
if ((temp != pattern) && (offset != test_offset)) { if ((temp != pattern) && (offset != test_offset)) {
printf("\nFAILURE: Address bit stuck low or" printf("\nFAILURE: Address bit stuck low or"
" shorted @ 0x%.8lx: expected 0x%.8lx," " shorted @ 0x%.8lx: expected 0x%.8lx,"
" actual 0x%.8lx\n", " actual 0x%.8lx\n",
(ulong)&start[offset], pattern, temp); start_addr + offset, pattern, temp);
errs++; errs++;
if (ctrlc()) if (ctrlc())
return -1; return -1;
} }
} }
start[test_offset] = pattern; addr[test_offset] = pattern;
} }
/* /*
@ -806,14 +801,14 @@ static ulong mem_test_alt(ulong start_addr, ulong end_addr)
* *
* Returns: 0 if the test succeeds, 1 if the test fails. * Returns: 0 if the test succeeds, 1 if the test fails.
*/ */
num_words = ((ulong)end - (ulong)start)/sizeof(vu_long) + 1; num_words++;
/* /*
* Fill memory with a known pattern. * Fill memory with a known pattern.
*/ */
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET(); WATCHDOG_RESET();
start[offset] = pattern; addr[offset] = pattern;
} }
/* /*
@ -821,18 +816,18 @@ static ulong mem_test_alt(ulong start_addr, ulong end_addr)
*/ */
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET(); WATCHDOG_RESET();
temp = start[offset]; temp = addr[offset];
if (temp != pattern) { if (temp != pattern) {
printf("\nFAILURE (read/write) @ 0x%.8lx:" printf("\nFAILURE (read/write) @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx)\n", " expected 0x%.8lx, actual 0x%.8lx)\n",
(ulong)&start[offset], pattern, temp); start_addr + offset, pattern, temp);
errs++; errs++;
if (ctrlc()) if (ctrlc())
return -1; return -1;
} }
anti_pattern = ~pattern; anti_pattern = ~pattern;
start[offset] = anti_pattern; addr[offset] = anti_pattern;
} }
/* /*
@ -841,28 +836,28 @@ static ulong mem_test_alt(ulong start_addr, ulong end_addr)
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET(); WATCHDOG_RESET();
anti_pattern = ~pattern; anti_pattern = ~pattern;
temp = start[offset]; temp = addr[offset];
if (temp != anti_pattern) { if (temp != anti_pattern) {
printf("\nFAILURE (read/write): @ 0x%.8lx:" printf("\nFAILURE (read/write): @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx)\n", " expected 0x%.8lx, actual 0x%.8lx)\n",
(ulong)&start[offset], anti_pattern, temp); start_addr + offset, anti_pattern, temp);
errs++; errs++;
if (ctrlc()) if (ctrlc())
return -1; return -1;
} }
start[offset] = 0; addr[offset] = 0;
} }
return 0; return 0;
} }
static ulong mem_test_quick(ulong start_addr, ulong end_addr, vu_long pattern, static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
int iteration) vu_long pattern, int iteration)
{ {
vu_long *start, *end; vu_long *end;
vu_long *addr; vu_long *addr;
ulong errs = 0; ulong errs = 0;
ulong incr; ulong incr, length;
ulong val, readback; ulong val, readback;
/* Alternate the pattern */ /* Alternate the pattern */
@ -880,14 +875,14 @@ static ulong mem_test_quick(ulong start_addr, ulong end_addr, vu_long pattern,
else else
pattern = ~pattern; pattern = ~pattern;
} }
start = (vu_long *)start_addr; length = (end_addr - start_addr) / sizeof(ulong);
end = (vu_long *)end_addr; end = buf + length;
printf("\rPattern %08lX Writing..." printf("\rPattern %08lX Writing..."
"%12s" "%12s"
"\b\b\b\b\b\b\b\b\b\b", "\b\b\b\b\b\b\b\b\b\b",
pattern, ""); pattern, "");
for (addr = start, val = pattern; addr < end; addr++) { for (addr = buf, val = pattern; addr < end; addr++) {
WATCHDOG_RESET(); WATCHDOG_RESET();
*addr = val; *addr = val;
val += incr; val += incr;
@ -895,13 +890,16 @@ static ulong mem_test_quick(ulong start_addr, ulong end_addr, vu_long pattern,
puts("Reading..."); puts("Reading...");
for (addr = start, val = pattern; addr < end; addr++) { for (addr = buf, val = pattern; addr < end; addr++) {
WATCHDOG_RESET(); WATCHDOG_RESET();
readback = *addr; readback = *addr;
if (readback != val) { if (readback != val) {
ulong offset = addr - buf;
printf("\nMem error @ 0x%08X: " printf("\nMem error @ 0x%08X: "
"found %08lX, expected %08lX\n", "found %08lX, expected %08lX\n",
(uint)(uintptr_t)addr, readback, val); (uint)(uintptr_t)(start_addr + offset),
readback, val);
errs++; errs++;
if (ctrlc()) if (ctrlc())
return -1; return -1;
@ -921,6 +919,7 @@ static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[]) char * const argv[])
{ {
ulong start, end; ulong start, end;
vu_long *buf, *dummy;
int iteration_limit; int iteration_limit;
int ret; int ret;
ulong errs = 0; /* number of errors, or -1 if interrupted */ ulong errs = 0; /* number of errors, or -1 if interrupted */
@ -956,6 +955,8 @@ static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__, debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__,
start, end); start, end);
buf = map_sysmem(start, end - start);
dummy = map_sysmem(CONFIG_SYS_MEMTEST_SCRATCH, sizeof(vu_long));
for (iteration = 0; for (iteration = 0;
!iteration_limit || iteration < iteration_limit; !iteration_limit || iteration < iteration_limit;
iteration++) { iteration++) {
@ -966,10 +967,27 @@ static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
printf("Iteration: %6d\r", iteration + 1); printf("Iteration: %6d\r", iteration + 1);
debug("\n"); debug("\n");
if (alt_test) if (alt_test) {
errs = mem_test_alt(start, end); errs = mem_test_alt(buf, start, end, dummy);
else } else {
errs = mem_test_quick(start, end, pattern, iteration); errs = mem_test_quick(buf, start, end, pattern,
iteration);
}
if (errs == -1UL)
break;
}
/*
* Work-around for eldk-4.2 which gives this warning if we try to
* case in the unmap_sysmem() call:
* warning: initialization discards qualifiers from pointer target type
*/
{
void *vbuf = (void *)buf;
void *vdummy = (void *)dummy;
unmap_sysmem(vbuf);
unmap_sysmem(vdummy);
} }
if (errs == -1UL) { if (errs == -1UL) {