#ifdef CONFIG_HAS_DATAFLASH
#include <dataflash.h>
#endif
+#include <hash.h>
#include <watchdog.h>
#include <asm/io.h>
#include <linux/compiler.h>
DECLARE_GLOBAL_DATA_PTR;
+#ifndef CONFIG_SYS_MEMTEST_SCRATCH
+#define CONFIG_SYS_MEMTEST_SCRATCH 0
+#endif
+
static int mod_mem(cmd_tbl_t *, int, int, int, char * const []);
/* Display values from last command.
#endif
bytes = size * count;
- buf = map_sysmem(addr, bytes);
+ buf = map_sysmem(dest, bytes);
src = map_sysmem(addr, bytes);
while (count-- > 0) {
if (size == 4)
*cp++;
}
unmap_sysmem(buf);
+
+ return 0;
}
#ifdef CONFIG_LOOPW
}
#endif /* CONFIG_LOOPW */
-static ulong mem_test_alt(ulong start_addr, ulong end_addr)
+#ifdef CONFIG_CMD_MEMTEST
+static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
+ vu_long *dummy)
{
- vu_long *start, *end;
vu_long *addr;
ulong errs = 0;
ulong val, readback;
int j;
- vu_long len;
vu_long offset;
vu_long test_offset;
vu_long pattern;
vu_long temp;
vu_long anti_pattern;
vu_long num_words;
-#if defined(CONFIG_SYS_MEMTEST_SCRATCH)
- vu_long *dummy = (vu_long *)CONFIG_SYS_MEMTEST_SCRATCH;
-#else
- vu_long *dummy = NULL; /* yes, this is address 0x0, not NULL */
-#endif
static const ulong bitpattern[] = {
0x00000001, /* single bit */
0x00000003, /* two adjacent bits */
0xaaaaaaaa, /* alternating 1/0 */
};
- start = (vu_long *)start_addr;
- end = (vu_long *)end_addr;
+ num_words = (end_addr - start_addr) / sizeof(vu_long);
/*
* Data line test: write a pattern to the first
* '0's and '0' bits through a field of '1's (i.e.
* pattern and ~pattern).
*/
- addr = start;
+ addr = buf;
for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) {
val = bitpattern[j];
for (; val != 0; val <<= 1) {
- *addr = val;
+ *addr = val;
*dummy = ~val; /* clear the test data off the bus */
readback = *addr;
if (readback != val) {
*
* Returns: 0 if the test succeeds, 1 if the test fails.
*/
- len = (end_addr - start_addr) / sizeof(vu_long);
pattern = (vu_long) 0xaaaaaaaa;
anti_pattern = (vu_long) 0x55555555;
- debug("%s:%d: length = 0x%.8lx\n",
- __func__, __LINE__, len);
+ debug("%s:%d: length = 0x%.8lx\n", __func__, __LINE__, num_words);
/*
* Write the default pattern at each of the
* power-of-two offsets.
*/
- for (offset = 1; offset < len; offset <<= 1)
- start[offset] = pattern;
+ for (offset = 1; offset < num_words; offset <<= 1)
+ addr[offset] = pattern;
/*
* Check for address bits stuck high.
*/
test_offset = 0;
- start[test_offset] = anti_pattern;
+ addr[test_offset] = anti_pattern;
- for (offset = 1; offset < len; offset <<= 1) {
- temp = start[offset];
+ for (offset = 1; offset < num_words; offset <<= 1) {
+ temp = addr[offset];
if (temp != pattern) {
printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx\n",
- (ulong)&start[offset], pattern, temp);
+ start_addr + offset, pattern, temp);
errs++;
if (ctrlc())
return -1;
}
}
- start[test_offset] = pattern;
+ addr[test_offset] = pattern;
WATCHDOG_RESET();
/*
* Check for addr bits stuck low or shorted.
*/
- for (test_offset = 1; test_offset < len; test_offset <<= 1) {
- start[test_offset] = anti_pattern;
+ for (test_offset = 1; test_offset < num_words; test_offset <<= 1) {
+ addr[test_offset] = anti_pattern;
- for (offset = 1; offset < len; offset <<= 1) {
- temp = start[offset];
+ for (offset = 1; offset < num_words; offset <<= 1) {
+ temp = addr[offset];
if ((temp != pattern) && (offset != test_offset)) {
printf("\nFAILURE: Address bit stuck low or"
" shorted @ 0x%.8lx: expected 0x%.8lx,"
" actual 0x%.8lx\n",
- (ulong)&start[offset], pattern, temp);
+ start_addr + offset, pattern, temp);
errs++;
if (ctrlc())
return -1;
}
}
- start[test_offset] = pattern;
+ addr[test_offset] = pattern;
}
/*
*
* 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.
*/
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET();
- start[offset] = pattern;
+ addr[offset] = pattern;
}
/*
*/
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET();
- temp = start[offset];
+ temp = addr[offset];
if (temp != pattern) {
printf("\nFAILURE (read/write) @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx)\n",
- (ulong)&start[offset], pattern, temp);
+ start_addr + offset, pattern, temp);
errs++;
if (ctrlc())
return -1;
}
anti_pattern = ~pattern;
- start[offset] = anti_pattern;
+ addr[offset] = anti_pattern;
}
/*
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET();
anti_pattern = ~pattern;
- temp = start[offset];
+ temp = addr[offset];
if (temp != anti_pattern) {
printf("\nFAILURE (read/write): @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx)\n",
- (ulong)&start[offset], anti_pattern, temp);
+ start_addr + offset, anti_pattern, temp);
errs++;
if (ctrlc())
return -1;
}
- start[offset] = 0;
+ addr[offset] = 0;
}
return 0;
}
-static ulong mem_test_quick(ulong start_addr, ulong end_addr, vu_long pattern,
- int iteration)
+static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
+ vu_long pattern, int iteration)
{
- vu_long *start, *end;
+ vu_long *end;
vu_long *addr;
ulong errs = 0;
- ulong incr;
+ ulong incr, length;
ulong val, readback;
/* Alternate the pattern */
else
pattern = ~pattern;
}
- start = (vu_long *)start_addr;
- end = (vu_long *)end_addr;
+ length = (end_addr - start_addr) / sizeof(ulong);
+ end = buf + length;
printf("\rPattern %08lX Writing..."
"%12s"
"\b\b\b\b\b\b\b\b\b\b",
pattern, "");
- for (addr = start, val = pattern; addr < end; addr++) {
+ for (addr = buf, val = pattern; addr < end; addr++) {
WATCHDOG_RESET();
*addr = val;
val += incr;
puts("Reading...");
- for (addr = start, val = pattern; addr < end; addr++) {
+ for (addr = buf, val = pattern; addr < end; addr++) {
WATCHDOG_RESET();
readback = *addr;
if (readback != val) {
+ ulong offset = addr - buf;
+
printf("\nMem error @ 0x%08X: "
"found %08lX, expected %08lX\n",
- (uint)(uintptr_t)addr, readback, val);
+ (uint)(uintptr_t)(start_addr + offset),
+ readback, val);
errs++;
if (ctrlc())
return -1;
char * const argv[])
{
ulong start, end;
+ vu_long *buf, *dummy;
int iteration_limit;
int ret;
ulong errs = 0; /* number of errors, or -1 if interrupted */
debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__,
start, end);
+ buf = map_sysmem(start, end - start);
+ dummy = map_sysmem(CONFIG_SYS_MEMTEST_SCRATCH, sizeof(vu_long));
for (iteration = 0;
!iteration_limit || iteration < iteration_limit;
iteration++) {
printf("Iteration: %6d\r", iteration + 1);
debug("\n");
- if (alt_test)
- errs = mem_test_alt(start, end);
- else
- errs = mem_test_quick(start, end, pattern, iteration);
+ if (alt_test) {
+ errs = mem_test_alt(buf, start, end, dummy);
+ } else {
+ 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) {
return ret; /* not reached */
}
-
+#endif /* CONFIG_CMD_MEMTEST */
/* Modify memory.
*
#ifdef CONFIG_CMD_CRC32
-#ifndef CONFIG_CRC32_VERIFY
-
static int do_mem_crc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
- ulong addr, length;
- ulong crc;
- ulong *ptr;
-
- if (argc < 3)
- return CMD_RET_USAGE;
-
- addr = simple_strtoul (argv[1], NULL, 16);
- addr += base_address;
-
- length = simple_strtoul (argv[2], NULL, 16);
-
- crc = crc32_wd (0, (const uchar *) addr, length, CHUNKSZ_CRC32);
-
- printf ("CRC32 for %08lx ... %08lx ==> %08lx\n",
- addr, addr + length - 1, crc);
-
- if (argc > 3) {
- ptr = (ulong *) simple_strtoul (argv[3], NULL, 16);
- *ptr = crc;
- }
-
- return 0;
-}
-
-#else /* CONFIG_CRC32_VERIFY */
-
-int do_mem_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
-{
- ulong addr, length;
- ulong crc;
- ulong *ptr;
- ulong vcrc;
- int verify;
+ int flags = 0;
int ac;
char * const *av;
- if (argc < 3) {
-usage:
+ if (argc < 3)
return CMD_RET_USAGE;
- }
av = argv + 1;
ac = argc - 1;
+#ifdef CONFIG_HASH_VERIFY
if (strcmp(*av, "-v") == 0) {
- verify = 1;
+ flags |= HASH_FLAG_VERIFY;
av++;
ac--;
- if (ac < 3)
- goto usage;
- } else
- verify = 0;
-
- addr = simple_strtoul(*av++, NULL, 16);
- addr += base_address;
- length = simple_strtoul(*av++, NULL, 16);
-
- crc = crc32_wd (0, (const uchar *) addr, length, CHUNKSZ_CRC32);
-
- if (!verify) {
- printf ("CRC32 for %08lx ... %08lx ==> %08lx\n",
- addr, addr + length - 1, crc);
- if (ac > 2) {
- ptr = (ulong *) simple_strtoul (*av++, NULL, 16);
- *ptr = crc;
- }
- } else {
- vcrc = simple_strtoul(*av++, NULL, 16);
- if (vcrc != crc) {
- printf ("CRC32 for %08lx ... %08lx ==> %08lx != %08lx ** ERROR **\n",
- addr, addr + length - 1, crc, vcrc);
- return 1;
- }
}
+#endif
- return 0;
-
+ return hash_command("crc32", flags, cmdtp, flag, ac, av);
}
-#endif /* CONFIG_CRC32_VERIFY */
#endif
);
#endif /* CONFIG_LOOPW */
+#ifdef CONFIG_CMD_MEMTEST
U_BOOT_CMD(
mtest, 5, 1, do_mem_mtest,
"simple RAM read/write test",
"[start [end [pattern [iterations]]]]"
);
+#endif /* CONFIG_CMD_MEMTEST */
#ifdef CONFIG_MX_CYCLIC
U_BOOT_CMD(