/* * (C) Copyright 2000 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. * * See file CREDITS for list of people who contributed to this * project. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA */ /* * Memory Functions * * Copied from FADS ROM, Dan Malek (dmalek@jlc.net) */ #include <common.h> #include <command.h> #include <driver.h> #include <malloc.h> #ifdef CMD_MEM_DEBUG #define PRINTF(fmt,args...) printf (fmt ,##args) #else #define PRINTF(fmt,args...) #endif #define RW_BUF_SIZE (ulong)4096 static char *rw_buf; /* Memory Display * * Syntax: * md{.b, .w, .l} {addr} {len} */ #define DISP_LINE_LEN 16 void memory_display(char *addr, ulong offs, ulong nbytes, int size) { ulong linebytes, i; u_char *cp; /* Print the lines. * * We buffer all read data, so we can make sure data is read only * once, and all accesses are with the specified bus width. */ do { char linebuf[DISP_LINE_LEN]; uint *uip = (uint *)linebuf; ushort *usp = (ushort *)linebuf; u_char *ucp = (u_char *)linebuf; printf("%08lx:", offs); linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes; for (i=0; i<linebytes; i+= size) { if (size == 4) { printf(" %08x", (*uip++ = *((uint *)addr))); } else if (size == 2) { printf(" %04x", (*usp++ = *((ushort *)addr))); } else { printf(" %02x", (*ucp++ = *((u_char *)addr))); } addr += size; offs += size; } puts (" "); cp = (u_char *)linebuf; for (i=0; i<linebytes; i++) { if ((*cp < 0x20) || (*cp > 0x7e)) putc ('.'); else printf("%c", *cp); cp++; } putc ('\n'); nbytes -= linebytes; if (ctrlc()) { return; } } while (nbytes > 0); } int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong offs, now; ulong nbytes = 0x100; struct memarea_info mem; int size, r; int rc = 0; if (argc < 2) { printf ("Usage:\n%s\n", cmdtp->usage); return 1; } if (spec_str_to_info(argv[1], &mem)) { printf("-ENOPARSE\n"); return -1; } if (mem.flags & MEMAREA_SIZE_SPECIFIED) nbytes = mem.size; else nbytes = min((ulong)0x100, mem.size); if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; offs = mem.start; do { now = min(RW_BUF_SIZE, nbytes); r = read(mem.device, rw_buf, now, offs, RW_SIZE(size)); if (r <= 0) return r; memory_display(rw_buf, offs, r, size); if (r < now) return 0; nbytes -= now; offs += now; } while (nbytes > 0); return (rc); } int do_mem_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr, writeval, count; struct memarea_info mem; ulong size; if ((argc < 3) || (argc > 4)) { printf ("Usage:\n%s\n", cmdtp->usage); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 1) return 1; if (spec_str_to_info(argv[1], &mem)) { printf("-ENOPARSE\n"); return -1; } addr = mem.start; /* Get the value to write. */ writeval = simple_strtoul(argv[2], NULL, 16); /* Count ? */ if (argc == 4) count = simple_strtoul(argv[3], NULL, 16); else count = size; if (count == size) { return write(mem.device, (uchar *)&writeval, count, mem.start, RW_SIZE(size)); } else { printf("write multiple not yet implemented\n"); } return 0; } int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr1, addr2, count, ngood; int size; int rcode = 0; if (argc != 4) { printf ("Usage:\n%s\n", cmdtp->usage); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr1 = simple_strtoul(argv[1], NULL, 16); addr2 = simple_strtoul(argv[2], NULL, 16); count = simple_strtoul(argv[3], NULL, 16); ngood = 0; while (count-- > 0) { if (size == 4) { ulong word1 = *(ulong *)addr1; ulong word2 = *(ulong *)addr2; if (word1 != word2) { printf("word at 0x%08lx (0x%08lx) " "!= word at 0x%08lx (0x%08lx)\n", addr1, word1, addr2, word2); rcode = 1; break; } } else if (size == 2) { ushort hword1 = *(ushort *)addr1; ushort hword2 = *(ushort *)addr2; if (hword1 != hword2) { printf("halfword at 0x%08lx (0x%04x) " "!= halfword at 0x%08lx (0x%04x)\n", addr1, hword1, addr2, hword2); rcode = 1; break; } } else { u_char byte1 = *(u_char *)addr1; u_char byte2 = *(u_char *)addr2; if (byte1 != byte2) { printf("byte at 0x%08lx (0x%02x) " "!= byte at 0x%08lx (0x%02x)\n", addr1, byte1, addr2, byte2); rcode = 1; break; } } ngood++; addr1 += size; addr2 += size; } printf("Total of %ld %s%s were the same\n", ngood, size == 4 ? "word" : size == 2 ? "halfword" : "byte", ngood == 1 ? "" : "s"); return rcode; } int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong count, offset, now; int ret; struct memarea_info dst, src; int size; if (argc != 3) { printf ("Usage:\n%s\n", cmdtp->usage); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; if (spec_str_to_info(argv[1], &src)) { printf("-ENOPARSE\n"); return -1; } if (spec_str_to_info(argv[2], &dst)) { printf("-ENOPARSE\n"); return -1; } if (!src.size || !dst.size) count = dst.size | src.size; else count = min(src.size, dst.size); printf("copy from 0x%08x to 0x%08x count %d\n",src.start, dst.start, count); offset = 0; while (count > 0) { now = min(RW_BUF_SIZE, count); ret = read(src.device, rw_buf, now, src.start + offset, RW_SIZE(size)); if (ret <= 0) return ret; ret = write(dst.device, rw_buf, ret, dst.start + offset, RW_SIZE(size)); if (ret <= 0) return ret; if (ret < now) return 0; offset += now; count -= now; } return 0; } /* * Perform a memory test. A more complete alternative test can be * configured using CFG_ALT_MEMTEST. The complete test loops until * interrupted by ctrl-c or by a failure of one of the sub-tests. */ int do_mem_mtest (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { vu_long *addr, *start, *end; ulong val; ulong readback; #if defined(CFG_ALT_MEMTEST) vu_long addr_mask; vu_long offset; vu_long test_offset; vu_long pattern; vu_long temp; vu_long anti_pattern; vu_long num_words; #if defined(CFG_MEMTEST_SCRATCH) vu_long *dummy = (vu_long*)CFG_MEMTEST_SCRATCH; #else vu_long *dummy = 0; /* yes, this is address 0x0, not NULL */ #endif int j; int iterations = 1; static const ulong bitpattern[] = { 0x00000001, /* single bit */ 0x00000003, /* two adjacent bits */ 0x00000007, /* three adjacent bits */ 0x0000000F, /* four adjacent bits */ 0x00000005, /* two non-adjacent bits */ 0x00000015, /* three non-adjacent bits */ 0x00000055, /* four non-adjacent bits */ 0xaaaaaaaa, /* alternating 1/0 */ }; #else ulong incr; ulong pattern; int rcode = 0; #endif if (argc > 1) { start = (ulong *)simple_strtoul(argv[1], NULL, 16); } else { start = (ulong *)CFG_MEMTEST_START; } if (argc > 2) { end = (ulong *)simple_strtoul(argv[2], NULL, 16); } else { end = (ulong *)(CFG_MEMTEST_END); } if (argc > 3) { pattern = (ulong)simple_strtoul(argv[3], NULL, 16); } else { pattern = 0; } #if defined(CFG_ALT_MEMTEST) printf ("Testing %08x ... %08x:\n", (uint)start, (uint)end); PRINTF("%s:%d: start 0x%p end 0x%p\n", __FUNCTION__, __LINE__, start, end); for (;;) { if (ctrlc()) { putc ('\n'); return 1; } printf("Iteration: %6d\r", iterations); PRINTF("Iteration: %6d\n", iterations); iterations++; /* * Data line test: write a pattern to the first * location, write the 1's complement to a 'parking' * address (changes the state of the data bus so a * floating bus doen't give a false OK), and then * read the value back. Note that we read it back * into a variable because the next time we read it, * it might be right (been there, tough to explain to * the quality guys why it prints a failure when the * "is" and "should be" are obviously the same in the * error message). * * Rather than exhaustively testing, we test some * patterns by shifting '1' bits through a field of * '0's and '0' bits through a field of '1's (i.e. * pattern and ~pattern). */ addr = start; for (j = 0; j < sizeof(bitpattern)/sizeof(bitpattern[0]); j++) { val = bitpattern[j]; for(; val != 0; val <<= 1) { *addr = val; *dummy = ~val; /* clear the test data off of the bus */ readback = *addr; if(readback != val) { printf ("FAILURE (data line): " "expected %08lx, actual %08lx\n", val, readback); } *addr = ~val; *dummy = val; readback = *addr; if(readback != ~val) { printf ("FAILURE (data line): " "Is %08lx, should be %08lx\n", readback, ~val); } } } /* * Based on code whose Original Author and Copyright * information follows: Copyright (c) 1998 by Michael * Barr. This software is placed into the public * domain and may be used for any purpose. However, * this notice must not be changed or removed and no * warranty is either expressed or implied by its * publication or distribution. */ /* * Address line test * * Description: Test the address bus wiring in a * memory region by performing a walking * 1's test on the relevant bits of the * address and checking for aliasing. * This test will find single-bit * address failures such as stuck -high, * stuck-low, and shorted pins. The base * address and size of the region are * selected by the caller. * * Notes: For best results, the selected base * address should have enough LSB 0's to * guarantee single address bit changes. * For example, to test a 64-Kbyte * region, select a base address on a * 64-Kbyte boundary. Also, select the * region size as a power-of-two if at * all possible. * * Returns: 0 if the test succeeds, 1 if the test fails. * * ## NOTE ## Be sure to specify start and end * addresses such that addr_mask has * lots of bits set. For example an * address range of 01000000 02000000 is * bad while a range of 01000000 * 01ffffff is perfect. */ addr_mask = ((ulong)end - (ulong)start)/sizeof(vu_long); pattern = (vu_long) 0xaaaaaaaa; anti_pattern = (vu_long) 0x55555555; PRINTF("%s:%d: addr mask = 0x%.8lx\n", __FUNCTION__, __LINE__, addr_mask); /* * Write the default pattern at each of the * power-of-two offsets. */ for (offset = 1; (offset & addr_mask) != 0; offset <<= 1) { start[offset] = pattern; } /* * Check for address bits stuck high. */ test_offset = 0; start[test_offset] = anti_pattern; for (offset = 1; (offset & addr_mask) != 0; offset <<= 1) { temp = start[offset]; if (temp != pattern) { printf ("\nFAILURE: Address bit stuck high @ 0x%.8lx:" " expected 0x%.8lx, actual 0x%.8lx\n", (ulong)&start[offset], pattern, temp); return 1; } } start[test_offset] = pattern; /* * Check for addr bits stuck low or shorted. */ for (test_offset = 1; (test_offset & addr_mask) != 0; test_offset <<= 1) { start[test_offset] = anti_pattern; for (offset = 1; (offset & addr_mask) != 0; offset <<= 1) { temp = start[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); return 1; } } start[test_offset] = pattern; } /* * Description: Test the integrity of a physical * memory device by performing an * increment/decrement test over the * entire region. In the process every * storage bit in the device is tested * as a zero and a one. The base address * and the size of the region are * selected by the caller. * * Returns: 0 if the test succeeds, 1 if the test fails. */ num_words = ((ulong)end - (ulong)start)/sizeof(vu_long) + 1; /* * Fill memory with a known pattern. */ for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { start[offset] = pattern; } /* * Check each location and invert it for the second pass. */ for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { temp = start[offset]; if (temp != pattern) { printf ("\nFAILURE (read/write) @ 0x%.8lx:" " expected 0x%.8lx, actual 0x%.8lx)\n", (ulong)&start[offset], pattern, temp); return 1; } anti_pattern = ~pattern; start[offset] = anti_pattern; } /* * Check each location for the inverted pattern and zero it. */ for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { anti_pattern = ~pattern; temp = start[offset]; if (temp != anti_pattern) { printf ("\nFAILURE (read/write): @ 0x%.8lx:" " expected 0x%.8lx, actual 0x%.8lx)\n", (ulong)&start[offset], anti_pattern, temp); return 1; } start[offset] = 0; } } #else /* The original, quickie test */ incr = 1; for (;;) { if (ctrlc()) { putc ('\n'); return 1; } printf ("\rPattern %08lX Writing..." "%12s" "\b\b\b\b\b\b\b\b\b\b", pattern, ""); for (addr=start,val=pattern; addr<end; addr++) { *addr = val; val += incr; } puts ("Reading..."); for (addr=start,val=pattern; addr<end; addr++) { readback = *addr; if (readback != val) { printf ("\nMem error @ 0x%08X: " "found %08lX, expected %08lX\n", (uint)addr, readback, val); rcode = 1; } val += incr; } /* * Flip the pattern each time to make lots of zeros and * then, the next time, lots of ones. We decrement * the "negative" patterns and increment the "positive" * patterns to preserve this feature. */ if(pattern & 0x80000000) { pattern = -pattern; /* complement & increment */ } else { pattern = ~pattern; } incr = -incr; } return rcode; #endif } #ifndef CONFIG_CRC32_VERIFY int do_mem_crc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr, length; ulong crc; ulong *ptr; if (argc < 3) { printf ("Usage:\n%s\n", cmdtp->usage); return 1; } addr = simple_strtoul (argv[1], NULL, 16); length = simple_strtoul (argv[2], NULL, 16); crc = crc32 (0, (const uchar *) addr, length); 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 *argv[]) { ulong addr, length; ulong crc; ulong *ptr; ulong vcrc; int verify; int ac; char **av; if (argc < 3) { usage: printf ("Usage:\n%s\n", cmdtp->usage); return 1; } av = argv + 1; ac = argc - 1; if (strcmp(*av, "-v") == 0) { verify = 1; av++; ac--; if (ac < 3) goto usage; } else verify = 0; addr = simple_strtoul(*av++, NULL, 16); length = simple_strtoul(*av++, NULL, 16); crc = crc32(0, (const uchar *) addr, length); 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; } } return 0; } #endif /* CONFIG_CRC32_VERIFY */ int mem_probe(struct device_d *dev) { return 0; } static void memcpy_sz(void *_dst, void *_src, ulong count, ulong rwsize) { ulong dst = (ulong)_dst; ulong src = (ulong)_src; if (!rwsize) { memcpy(_dst, _src, count); return; } count /= rwsize; while (count-- > 0) { switch (rwsize) { case 1: *((u_char *)dst) = *((u_char *)src); break; case 2: *((ushort *)dst) = *((ushort *)src); break; case 4: *((ulong *)dst) = *((ulong *)src); break; } dst += rwsize; src += rwsize; } } ssize_t mem_read(struct device_d *dev, void *buf, size_t count, ulong offset, ulong rwflags) { memcpy_sz(buf, (void *)(dev->map_base + offset), count, rwflags & RW_SIZE_MASK); return count; } ssize_t mem_write(struct device_d *dev, void *buf, size_t count, ulong offset, ulong rwflags) { memcpy_sz((void *)(dev->map_base + offset), buf, count, rwflags & RW_SIZE_MASK); return count; } struct device_d mem_dev = { .name = "mem", .id = "mem", .map_base = 0, .size = ~0, /* FIXME: should be 0x100000000, ahem... */ }; struct driver_d mem_drv = { .name = "mem", .probe = mem_probe, .read = mem_read, .write = mem_write, }; struct driver_d ram_drv = { .name = "ram", .probe = mem_probe, .read = mem_read, .write = mem_write, }; int mem_init(void) { rw_buf = malloc(RW_BUF_SIZE); if(!rw_buf) { printf("Out of memory\n"); return -1; } register_device(&mem_dev); register_driver(&mem_drv); register_driver(&ram_drv); return 0; } U_BOOT_CMD( md, 3, 0, do_mem_md, "md - memory display\n", "[.b, .w, .l] address [# of objects]\n - memory display\n" ); U_BOOT_CMD( mw, 4, 0, do_mem_mw, "mw - memory write (fill)\n", "[.b, .w, .l] address value [count]\n - write memory\n" ); U_BOOT_CMD( cp, 4, 0, do_mem_cp, "cp - memory copy\n", "[.b, .w, .l] source target count\n - copy memory\n" ); U_BOOT_CMD( cmp, 4, 0, do_mem_cmp, "cmp - memory compare\n", "[.b, .w, .l] addr1 addr2 count\n - compare memory\n" ); #ifndef CONFIG_CRC32_VERIFY U_BOOT_CMD( crc32, 4, 0, do_mem_crc, "crc32 - checksum calculation\n", "address count [addr]\n - compute CRC32 checksum [save at addr]\n" ); #else /* CONFIG_CRC32_VERIFY */ U_BOOT_CMD( crc32, 5, 0, do_mem_crc, "crc32 - checksum calculation\n", "address count [addr]\n - compute CRC32 checksum [save at addr]\n" "-v address count crc\n - verify crc of memory area\n" ); #endif /* CONFIG_CRC32_VERIFY */ #ifdef CONFIG_LOOPW U_BOOT_CMD( loopw, 4, 0, do_mem_loopw, "loopw - infinite write loop on address range\n", "[.b, .w, .l] address number_of_objects data_to_write\n" " - loop on a set of addresses\n" ); #endif /* CONFIG_LOOPW */ U_BOOT_CMD( mtest, 4, 0, do_mem_mtest, "mtest - simple RAM test\n", "[start [end [pattern]]]\n" " - simple RAM read/write test\n" ); #ifdef CONFIG_MX_CYCLIC U_BOOT_CMD( mdc, 4, 0, do_mem_mdc, "mdc - memory display cyclic\n", "[.b, .w, .l] address count delay(ms)\n - memory display cyclic\n" ); U_BOOT_CMD( mwc, 4, 0, do_mem_mwc, "mwc - memory write cyclic\n", "[.b, .w, .l] address value delay(ms)\n - memory write cyclic\n" ); #endif /* CONFIG_MX_CYCLIC */