12e192b24SSimon Glass /* 22e192b24SSimon Glass * (C) Copyright 2000 32e192b24SSimon Glass * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 42e192b24SSimon Glass * 52e192b24SSimon Glass * SPDX-License-Identifier: GPL-2.0+ 62e192b24SSimon Glass */ 72e192b24SSimon Glass 82e192b24SSimon Glass /* 92e192b24SSimon Glass * Memory Functions 102e192b24SSimon Glass * 112e192b24SSimon Glass * Copied from FADS ROM, Dan Malek (dmalek@jlc.net) 122e192b24SSimon Glass */ 132e192b24SSimon Glass 142e192b24SSimon Glass #include <common.h> 152e192b24SSimon Glass #include <console.h> 162e192b24SSimon Glass #include <bootretry.h> 172e192b24SSimon Glass #include <cli.h> 182e192b24SSimon Glass #include <command.h> 192e192b24SSimon Glass #include <console.h> 202e192b24SSimon Glass #ifdef CONFIG_HAS_DATAFLASH 212e192b24SSimon Glass #include <dataflash.h> 222e192b24SSimon Glass #endif 232e192b24SSimon Glass #include <hash.h> 242e192b24SSimon Glass #include <inttypes.h> 252e192b24SSimon Glass #include <mapmem.h> 262e192b24SSimon Glass #include <watchdog.h> 272e192b24SSimon Glass #include <asm/io.h> 282e192b24SSimon Glass #include <linux/compiler.h> 292e192b24SSimon Glass 302e192b24SSimon Glass DECLARE_GLOBAL_DATA_PTR; 312e192b24SSimon Glass 322e192b24SSimon Glass #ifndef CONFIG_SYS_MEMTEST_SCRATCH 332e192b24SSimon Glass #define CONFIG_SYS_MEMTEST_SCRATCH 0 342e192b24SSimon Glass #endif 352e192b24SSimon Glass 362e192b24SSimon Glass static int mod_mem(cmd_tbl_t *, int, int, int, char * const []); 372e192b24SSimon Glass 382e192b24SSimon Glass /* Display values from last command. 392e192b24SSimon Glass * Memory modify remembered values are different from display memory. 402e192b24SSimon Glass */ 412e192b24SSimon Glass static ulong dp_last_addr, dp_last_size; 422e192b24SSimon Glass static ulong dp_last_length = 0x40; 432e192b24SSimon Glass static ulong mm_last_addr, mm_last_size; 442e192b24SSimon Glass 452e192b24SSimon Glass static ulong base_address = 0; 462e192b24SSimon Glass 472e192b24SSimon Glass /* Memory Display 482e192b24SSimon Glass * 492e192b24SSimon Glass * Syntax: 502e192b24SSimon Glass * md{.b, .w, .l, .q} {addr} {len} 512e192b24SSimon Glass */ 522e192b24SSimon Glass #define DISP_LINE_LEN 16 532e192b24SSimon Glass static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 542e192b24SSimon Glass { 552e192b24SSimon Glass ulong addr, length; 562e192b24SSimon Glass #if defined(CONFIG_HAS_DATAFLASH) 572e192b24SSimon Glass ulong nbytes, linebytes; 582e192b24SSimon Glass #endif 592e192b24SSimon Glass int size; 602e192b24SSimon Glass int rc = 0; 612e192b24SSimon Glass 622e192b24SSimon Glass /* We use the last specified parameters, unless new ones are 632e192b24SSimon Glass * entered. 642e192b24SSimon Glass */ 652e192b24SSimon Glass addr = dp_last_addr; 662e192b24SSimon Glass size = dp_last_size; 672e192b24SSimon Glass length = dp_last_length; 682e192b24SSimon Glass 692e192b24SSimon Glass if (argc < 2) 702e192b24SSimon Glass return CMD_RET_USAGE; 712e192b24SSimon Glass 722e192b24SSimon Glass if ((flag & CMD_FLAG_REPEAT) == 0) { 732e192b24SSimon Glass /* New command specified. Check for a size specification. 742e192b24SSimon Glass * Defaults to long if no or incorrect specification. 752e192b24SSimon Glass */ 762e192b24SSimon Glass if ((size = cmd_get_data_size(argv[0], 4)) < 0) 772e192b24SSimon Glass return 1; 782e192b24SSimon Glass 792e192b24SSimon Glass /* Address is specified since argc > 1 802e192b24SSimon Glass */ 812e192b24SSimon Glass addr = simple_strtoul(argv[1], NULL, 16); 822e192b24SSimon Glass addr += base_address; 832e192b24SSimon Glass 842e192b24SSimon Glass /* If another parameter, it is the length to display. 852e192b24SSimon Glass * Length is the number of objects, not number of bytes. 862e192b24SSimon Glass */ 872e192b24SSimon Glass if (argc > 2) 882e192b24SSimon Glass length = simple_strtoul(argv[2], NULL, 16); 892e192b24SSimon Glass } 902e192b24SSimon Glass 912e192b24SSimon Glass #if defined(CONFIG_HAS_DATAFLASH) 922e192b24SSimon Glass /* Print the lines. 932e192b24SSimon Glass * 942e192b24SSimon Glass * We buffer all read data, so we can make sure data is read only 952e192b24SSimon Glass * once, and all accesses are with the specified bus width. 962e192b24SSimon Glass */ 972e192b24SSimon Glass nbytes = length * size; 982e192b24SSimon Glass do { 992e192b24SSimon Glass char linebuf[DISP_LINE_LEN]; 1002e192b24SSimon Glass void* p; 1012e192b24SSimon Glass linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes; 1022e192b24SSimon Glass 1032e192b24SSimon Glass rc = read_dataflash(addr, (linebytes/size)*size, linebuf); 1042e192b24SSimon Glass p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr; 1052e192b24SSimon Glass print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size); 1062e192b24SSimon Glass 1072e192b24SSimon Glass nbytes -= linebytes; 1082e192b24SSimon Glass addr += linebytes; 1092e192b24SSimon Glass if (ctrlc()) { 1102e192b24SSimon Glass rc = 1; 1112e192b24SSimon Glass break; 1122e192b24SSimon Glass } 1132e192b24SSimon Glass } while (nbytes > 0); 1142e192b24SSimon Glass #else 1152e192b24SSimon Glass 1162e192b24SSimon Glass # if defined(CONFIG_BLACKFIN) 1172e192b24SSimon Glass /* See if we're trying to display L1 inst */ 1182e192b24SSimon Glass if (addr_bfin_on_chip_mem(addr)) { 1192e192b24SSimon Glass char linebuf[DISP_LINE_LEN]; 1202e192b24SSimon Glass ulong linebytes, nbytes = length * size; 1212e192b24SSimon Glass do { 1222e192b24SSimon Glass linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes; 1232e192b24SSimon Glass memcpy(linebuf, (void *)addr, linebytes); 1242e192b24SSimon Glass print_buffer(addr, linebuf, size, linebytes/size, DISP_LINE_LEN/size); 1252e192b24SSimon Glass 1262e192b24SSimon Glass nbytes -= linebytes; 1272e192b24SSimon Glass addr += linebytes; 1282e192b24SSimon Glass if (ctrlc()) { 1292e192b24SSimon Glass rc = 1; 1302e192b24SSimon Glass break; 1312e192b24SSimon Glass } 1322e192b24SSimon Glass } while (nbytes > 0); 1332e192b24SSimon Glass } else 1342e192b24SSimon Glass # endif 1352e192b24SSimon Glass 1362e192b24SSimon Glass { 1372e192b24SSimon Glass ulong bytes = size * length; 1382e192b24SSimon Glass const void *buf = map_sysmem(addr, bytes); 1392e192b24SSimon Glass 1402e192b24SSimon Glass /* Print the lines. */ 1412e192b24SSimon Glass print_buffer(addr, buf, size, length, DISP_LINE_LEN / size); 1422e192b24SSimon Glass addr += bytes; 1432e192b24SSimon Glass unmap_sysmem(buf); 1442e192b24SSimon Glass } 1452e192b24SSimon Glass #endif 1462e192b24SSimon Glass 1472e192b24SSimon Glass dp_last_addr = addr; 1482e192b24SSimon Glass dp_last_length = length; 1492e192b24SSimon Glass dp_last_size = size; 1502e192b24SSimon Glass return (rc); 1512e192b24SSimon Glass } 1522e192b24SSimon Glass 1532e192b24SSimon Glass static int do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 1542e192b24SSimon Glass { 1552e192b24SSimon Glass return mod_mem (cmdtp, 1, flag, argc, argv); 1562e192b24SSimon Glass } 1572e192b24SSimon Glass static int do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 1582e192b24SSimon Glass { 1592e192b24SSimon Glass return mod_mem (cmdtp, 0, flag, argc, argv); 1602e192b24SSimon Glass } 1612e192b24SSimon Glass 1622e192b24SSimon Glass static int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 1632e192b24SSimon Glass { 1642e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 1652e192b24SSimon Glass u64 writeval; 1662e192b24SSimon Glass #else 1672e192b24SSimon Glass ulong writeval; 1682e192b24SSimon Glass #endif 1692e192b24SSimon Glass ulong addr, count; 1702e192b24SSimon Glass int size; 1712e192b24SSimon Glass void *buf, *start; 1722e192b24SSimon Glass ulong bytes; 1732e192b24SSimon Glass 1742e192b24SSimon Glass if ((argc < 3) || (argc > 4)) 1752e192b24SSimon Glass return CMD_RET_USAGE; 1762e192b24SSimon Glass 1772e192b24SSimon Glass /* Check for size specification. 1782e192b24SSimon Glass */ 1792e192b24SSimon Glass if ((size = cmd_get_data_size(argv[0], 4)) < 1) 1802e192b24SSimon Glass return 1; 1812e192b24SSimon Glass 1822e192b24SSimon Glass /* Address is specified since argc > 1 1832e192b24SSimon Glass */ 1842e192b24SSimon Glass addr = simple_strtoul(argv[1], NULL, 16); 1852e192b24SSimon Glass addr += base_address; 1862e192b24SSimon Glass 1872e192b24SSimon Glass /* Get the value to write. 1882e192b24SSimon Glass */ 1892e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 1902e192b24SSimon Glass writeval = simple_strtoull(argv[2], NULL, 16); 1912e192b24SSimon Glass #else 1922e192b24SSimon Glass writeval = simple_strtoul(argv[2], NULL, 16); 1932e192b24SSimon Glass #endif 1942e192b24SSimon Glass 1952e192b24SSimon Glass /* Count ? */ 1962e192b24SSimon Glass if (argc == 4) { 1972e192b24SSimon Glass count = simple_strtoul(argv[3], NULL, 16); 1982e192b24SSimon Glass } else { 1992e192b24SSimon Glass count = 1; 2002e192b24SSimon Glass } 2012e192b24SSimon Glass 2022e192b24SSimon Glass bytes = size * count; 2032e192b24SSimon Glass start = map_sysmem(addr, bytes); 2042e192b24SSimon Glass buf = start; 2052e192b24SSimon Glass while (count-- > 0) { 2062e192b24SSimon Glass if (size == 4) 2072e192b24SSimon Glass *((u32 *)buf) = (u32)writeval; 2082e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 2092e192b24SSimon Glass else if (size == 8) 2102e192b24SSimon Glass *((u64 *)buf) = (u64)writeval; 2112e192b24SSimon Glass #endif 2122e192b24SSimon Glass else if (size == 2) 2132e192b24SSimon Glass *((u16 *)buf) = (u16)writeval; 2142e192b24SSimon Glass else 2152e192b24SSimon Glass *((u8 *)buf) = (u8)writeval; 2162e192b24SSimon Glass buf += size; 2172e192b24SSimon Glass } 2182e192b24SSimon Glass unmap_sysmem(start); 2192e192b24SSimon Glass return 0; 2202e192b24SSimon Glass } 2212e192b24SSimon Glass 2222e192b24SSimon Glass #ifdef CONFIG_MX_CYCLIC 2232e192b24SSimon Glass static int do_mem_mdc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 2242e192b24SSimon Glass { 2252e192b24SSimon Glass int i; 2262e192b24SSimon Glass ulong count; 2272e192b24SSimon Glass 2282e192b24SSimon Glass if (argc < 4) 2292e192b24SSimon Glass return CMD_RET_USAGE; 2302e192b24SSimon Glass 2312e192b24SSimon Glass count = simple_strtoul(argv[3], NULL, 10); 2322e192b24SSimon Glass 2332e192b24SSimon Glass for (;;) { 2342e192b24SSimon Glass do_mem_md (NULL, 0, 3, argv); 2352e192b24SSimon Glass 2362e192b24SSimon Glass /* delay for <count> ms... */ 2372e192b24SSimon Glass for (i=0; i<count; i++) 2382e192b24SSimon Glass udelay (1000); 2392e192b24SSimon Glass 2402e192b24SSimon Glass /* check for ctrl-c to abort... */ 2412e192b24SSimon Glass if (ctrlc()) { 2422e192b24SSimon Glass puts("Abort\n"); 2432e192b24SSimon Glass return 0; 2442e192b24SSimon Glass } 2452e192b24SSimon Glass } 2462e192b24SSimon Glass 2472e192b24SSimon Glass return 0; 2482e192b24SSimon Glass } 2492e192b24SSimon Glass 2502e192b24SSimon Glass static int do_mem_mwc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 2512e192b24SSimon Glass { 2522e192b24SSimon Glass int i; 2532e192b24SSimon Glass ulong count; 2542e192b24SSimon Glass 2552e192b24SSimon Glass if (argc < 4) 2562e192b24SSimon Glass return CMD_RET_USAGE; 2572e192b24SSimon Glass 2582e192b24SSimon Glass count = simple_strtoul(argv[3], NULL, 10); 2592e192b24SSimon Glass 2602e192b24SSimon Glass for (;;) { 2612e192b24SSimon Glass do_mem_mw (NULL, 0, 3, argv); 2622e192b24SSimon Glass 2632e192b24SSimon Glass /* delay for <count> ms... */ 2642e192b24SSimon Glass for (i=0; i<count; i++) 2652e192b24SSimon Glass udelay (1000); 2662e192b24SSimon Glass 2672e192b24SSimon Glass /* check for ctrl-c to abort... */ 2682e192b24SSimon Glass if (ctrlc()) { 2692e192b24SSimon Glass puts("Abort\n"); 2702e192b24SSimon Glass return 0; 2712e192b24SSimon Glass } 2722e192b24SSimon Glass } 2732e192b24SSimon Glass 2742e192b24SSimon Glass return 0; 2752e192b24SSimon Glass } 2762e192b24SSimon Glass #endif /* CONFIG_MX_CYCLIC */ 2772e192b24SSimon Glass 2782e192b24SSimon Glass static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 2792e192b24SSimon Glass { 2802e192b24SSimon Glass ulong addr1, addr2, count, ngood, bytes; 2812e192b24SSimon Glass int size; 2822e192b24SSimon Glass int rcode = 0; 2832e192b24SSimon Glass const char *type; 2842e192b24SSimon Glass const void *buf1, *buf2, *base; 2852e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 2862e192b24SSimon Glass u64 word1, word2; 2872e192b24SSimon Glass #else 2882e192b24SSimon Glass ulong word1, word2; 2892e192b24SSimon Glass #endif 2902e192b24SSimon Glass 2912e192b24SSimon Glass if (argc != 4) 2922e192b24SSimon Glass return CMD_RET_USAGE; 2932e192b24SSimon Glass 2942e192b24SSimon Glass /* Check for size specification. 2952e192b24SSimon Glass */ 2962e192b24SSimon Glass if ((size = cmd_get_data_size(argv[0], 4)) < 0) 2972e192b24SSimon Glass return 1; 2982e192b24SSimon Glass type = size == 8 ? "double word" : 2992e192b24SSimon Glass size == 4 ? "word" : 3002e192b24SSimon Glass size == 2 ? "halfword" : "byte"; 3012e192b24SSimon Glass 3022e192b24SSimon Glass addr1 = simple_strtoul(argv[1], NULL, 16); 3032e192b24SSimon Glass addr1 += base_address; 3042e192b24SSimon Glass 3052e192b24SSimon Glass addr2 = simple_strtoul(argv[2], NULL, 16); 3062e192b24SSimon Glass addr2 += base_address; 3072e192b24SSimon Glass 3082e192b24SSimon Glass count = simple_strtoul(argv[3], NULL, 16); 3092e192b24SSimon Glass 3102e192b24SSimon Glass #ifdef CONFIG_HAS_DATAFLASH 3112e192b24SSimon Glass if (addr_dataflash(addr1) | addr_dataflash(addr2)){ 3122e192b24SSimon Glass puts ("Comparison with DataFlash space not supported.\n\r"); 3132e192b24SSimon Glass return 0; 3142e192b24SSimon Glass } 3152e192b24SSimon Glass #endif 3162e192b24SSimon Glass 3172e192b24SSimon Glass #ifdef CONFIG_BLACKFIN 3182e192b24SSimon Glass if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) { 3192e192b24SSimon Glass puts ("Comparison with L1 instruction memory not supported.\n\r"); 3202e192b24SSimon Glass return 0; 3212e192b24SSimon Glass } 3222e192b24SSimon Glass #endif 3232e192b24SSimon Glass 3242e192b24SSimon Glass bytes = size * count; 3252e192b24SSimon Glass base = buf1 = map_sysmem(addr1, bytes); 3262e192b24SSimon Glass buf2 = map_sysmem(addr2, bytes); 3272e192b24SSimon Glass for (ngood = 0; ngood < count; ++ngood) { 3282e192b24SSimon Glass if (size == 4) { 3292e192b24SSimon Glass word1 = *(u32 *)buf1; 3302e192b24SSimon Glass word2 = *(u32 *)buf2; 3312e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 3322e192b24SSimon Glass } else if (size == 8) { 3332e192b24SSimon Glass word1 = *(u64 *)buf1; 3342e192b24SSimon Glass word2 = *(u64 *)buf2; 3352e192b24SSimon Glass #endif 3362e192b24SSimon Glass } else if (size == 2) { 3372e192b24SSimon Glass word1 = *(u16 *)buf1; 3382e192b24SSimon Glass word2 = *(u16 *)buf2; 3392e192b24SSimon Glass } else { 3402e192b24SSimon Glass word1 = *(u8 *)buf1; 3412e192b24SSimon Glass word2 = *(u8 *)buf2; 3422e192b24SSimon Glass } 3432e192b24SSimon Glass if (word1 != word2) { 3442e192b24SSimon Glass ulong offset = buf1 - base; 3452e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 3462e192b24SSimon Glass printf("%s at 0x%p (%#0*"PRIx64") != %s at 0x%p (%#0*" 3472e192b24SSimon Glass PRIx64 ")\n", 3482e192b24SSimon Glass type, (void *)(addr1 + offset), size, word1, 3492e192b24SSimon Glass type, (void *)(addr2 + offset), size, word2); 3502e192b24SSimon Glass #else 3512e192b24SSimon Glass printf("%s at 0x%08lx (%#0*lx) != %s at 0x%08lx (%#0*lx)\n", 3522e192b24SSimon Glass type, (ulong)(addr1 + offset), size, word1, 3532e192b24SSimon Glass type, (ulong)(addr2 + offset), size, word2); 3542e192b24SSimon Glass #endif 3552e192b24SSimon Glass rcode = 1; 3562e192b24SSimon Glass break; 3572e192b24SSimon Glass } 3582e192b24SSimon Glass 3592e192b24SSimon Glass buf1 += size; 3602e192b24SSimon Glass buf2 += size; 3612e192b24SSimon Glass 3622e192b24SSimon Glass /* reset watchdog from time to time */ 3632e192b24SSimon Glass if ((ngood % (64 << 10)) == 0) 3642e192b24SSimon Glass WATCHDOG_RESET(); 3652e192b24SSimon Glass } 3662e192b24SSimon Glass unmap_sysmem(buf1); 3672e192b24SSimon Glass unmap_sysmem(buf2); 3682e192b24SSimon Glass 3692e192b24SSimon Glass printf("Total of %ld %s(s) were the same\n", ngood, type); 3702e192b24SSimon Glass return rcode; 3712e192b24SSimon Glass } 3722e192b24SSimon Glass 3732e192b24SSimon Glass static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 3742e192b24SSimon Glass { 375*c2538421SFabio Estevam ulong addr, dest, count; 3762e192b24SSimon Glass int size; 3772e192b24SSimon Glass 3782e192b24SSimon Glass if (argc != 4) 3792e192b24SSimon Glass return CMD_RET_USAGE; 3802e192b24SSimon Glass 3812e192b24SSimon Glass /* Check for size specification. 3822e192b24SSimon Glass */ 3832e192b24SSimon Glass if ((size = cmd_get_data_size(argv[0], 4)) < 0) 3842e192b24SSimon Glass return 1; 3852e192b24SSimon Glass 3862e192b24SSimon Glass addr = simple_strtoul(argv[1], NULL, 16); 3872e192b24SSimon Glass addr += base_address; 3882e192b24SSimon Glass 3892e192b24SSimon Glass dest = simple_strtoul(argv[2], NULL, 16); 3902e192b24SSimon Glass dest += base_address; 3912e192b24SSimon Glass 3922e192b24SSimon Glass count = simple_strtoul(argv[3], NULL, 16); 3932e192b24SSimon Glass 3942e192b24SSimon Glass if (count == 0) { 3952e192b24SSimon Glass puts ("Zero length ???\n"); 3962e192b24SSimon Glass return 1; 3972e192b24SSimon Glass } 3982e192b24SSimon Glass 3992e192b24SSimon Glass #ifndef CONFIG_SYS_NO_FLASH 4002e192b24SSimon Glass /* check if we are copying to Flash */ 4012e192b24SSimon Glass if ( (addr2info(dest) != NULL) 4022e192b24SSimon Glass #ifdef CONFIG_HAS_DATAFLASH 4032e192b24SSimon Glass && (!addr_dataflash(dest)) 4042e192b24SSimon Glass #endif 4052e192b24SSimon Glass ) { 4062e192b24SSimon Glass int rc; 4072e192b24SSimon Glass 4082e192b24SSimon Glass puts ("Copy to Flash... "); 4092e192b24SSimon Glass 4102e192b24SSimon Glass rc = flash_write ((char *)addr, dest, count*size); 4112e192b24SSimon Glass if (rc != 0) { 4122e192b24SSimon Glass flash_perror (rc); 4132e192b24SSimon Glass return (1); 4142e192b24SSimon Glass } 4152e192b24SSimon Glass puts ("done\n"); 4162e192b24SSimon Glass return 0; 4172e192b24SSimon Glass } 4182e192b24SSimon Glass #endif 4192e192b24SSimon Glass 4202e192b24SSimon Glass #ifdef CONFIG_HAS_DATAFLASH 4212e192b24SSimon Glass /* Check if we are copying from RAM or Flash to DataFlash */ 4222e192b24SSimon Glass if (addr_dataflash(dest) && !addr_dataflash(addr)){ 4232e192b24SSimon Glass int rc; 4242e192b24SSimon Glass 4252e192b24SSimon Glass puts ("Copy to DataFlash... "); 4262e192b24SSimon Glass 4272e192b24SSimon Glass rc = write_dataflash (dest, addr, count*size); 4282e192b24SSimon Glass 4292e192b24SSimon Glass if (rc != 1) { 4302e192b24SSimon Glass dataflash_perror (rc); 4312e192b24SSimon Glass return (1); 4322e192b24SSimon Glass } 4332e192b24SSimon Glass puts ("done\n"); 4342e192b24SSimon Glass return 0; 4352e192b24SSimon Glass } 4362e192b24SSimon Glass 4372e192b24SSimon Glass /* Check if we are copying from DataFlash to RAM */ 4382e192b24SSimon Glass if (addr_dataflash(addr) && !addr_dataflash(dest) 4392e192b24SSimon Glass #ifndef CONFIG_SYS_NO_FLASH 4402e192b24SSimon Glass && (addr2info(dest) == NULL) 4412e192b24SSimon Glass #endif 4422e192b24SSimon Glass ){ 4432e192b24SSimon Glass int rc; 4442e192b24SSimon Glass rc = read_dataflash(addr, count * size, (char *) dest); 4452e192b24SSimon Glass if (rc != 1) { 4462e192b24SSimon Glass dataflash_perror (rc); 4472e192b24SSimon Glass return (1); 4482e192b24SSimon Glass } 4492e192b24SSimon Glass return 0; 4502e192b24SSimon Glass } 4512e192b24SSimon Glass 4522e192b24SSimon Glass if (addr_dataflash(addr) && addr_dataflash(dest)){ 4532e192b24SSimon Glass puts ("Unsupported combination of source/destination.\n\r"); 4542e192b24SSimon Glass return 1; 4552e192b24SSimon Glass } 4562e192b24SSimon Glass #endif 4572e192b24SSimon Glass 4582e192b24SSimon Glass #ifdef CONFIG_BLACKFIN 4592e192b24SSimon Glass /* See if we're copying to/from L1 inst */ 4602e192b24SSimon Glass if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { 4612e192b24SSimon Glass memcpy((void *)dest, (void *)addr, count * size); 4622e192b24SSimon Glass return 0; 4632e192b24SSimon Glass } 4642e192b24SSimon Glass #endif 4652e192b24SSimon Glass 466*c2538421SFabio Estevam memcpy((void *)dest, (void *)addr, count * size); 4672e192b24SSimon Glass 4682e192b24SSimon Glass return 0; 4692e192b24SSimon Glass } 4702e192b24SSimon Glass 4712e192b24SSimon Glass static int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc, 4722e192b24SSimon Glass char * const argv[]) 4732e192b24SSimon Glass { 4742e192b24SSimon Glass if (argc > 1) { 4752e192b24SSimon Glass /* Set new base address. 4762e192b24SSimon Glass */ 4772e192b24SSimon Glass base_address = simple_strtoul(argv[1], NULL, 16); 4782e192b24SSimon Glass } 4792e192b24SSimon Glass /* Print the current base address. 4802e192b24SSimon Glass */ 4812e192b24SSimon Glass printf("Base Address: 0x%08lx\n", base_address); 4822e192b24SSimon Glass return 0; 4832e192b24SSimon Glass } 4842e192b24SSimon Glass 4852e192b24SSimon Glass static int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc, 4862e192b24SSimon Glass char * const argv[]) 4872e192b24SSimon Glass { 4882e192b24SSimon Glass ulong addr, length, i, bytes; 4892e192b24SSimon Glass int size; 4902e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 4912e192b24SSimon Glass volatile u64 *llp; 4922e192b24SSimon Glass #endif 4932e192b24SSimon Glass volatile u32 *longp; 4942e192b24SSimon Glass volatile u16 *shortp; 4952e192b24SSimon Glass volatile u8 *cp; 4962e192b24SSimon Glass const void *buf; 4972e192b24SSimon Glass 4982e192b24SSimon Glass if (argc < 3) 4992e192b24SSimon Glass return CMD_RET_USAGE; 5002e192b24SSimon Glass 5012e192b24SSimon Glass /* 5022e192b24SSimon Glass * Check for a size specification. 5032e192b24SSimon Glass * Defaults to long if no or incorrect specification. 5042e192b24SSimon Glass */ 5052e192b24SSimon Glass if ((size = cmd_get_data_size(argv[0], 4)) < 0) 5062e192b24SSimon Glass return 1; 5072e192b24SSimon Glass 5082e192b24SSimon Glass /* Address is always specified. 5092e192b24SSimon Glass */ 5102e192b24SSimon Glass addr = simple_strtoul(argv[1], NULL, 16); 5112e192b24SSimon Glass 5122e192b24SSimon Glass /* Length is the number of objects, not number of bytes. 5132e192b24SSimon Glass */ 5142e192b24SSimon Glass length = simple_strtoul(argv[2], NULL, 16); 5152e192b24SSimon Glass 5162e192b24SSimon Glass bytes = size * length; 5172e192b24SSimon Glass buf = map_sysmem(addr, bytes); 5182e192b24SSimon Glass 5192e192b24SSimon Glass /* We want to optimize the loops to run as fast as possible. 5202e192b24SSimon Glass * If we have only one object, just run infinite loops. 5212e192b24SSimon Glass */ 5222e192b24SSimon Glass if (length == 1) { 5232e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 5242e192b24SSimon Glass if (size == 8) { 5252e192b24SSimon Glass llp = (u64 *)buf; 5262e192b24SSimon Glass for (;;) 5272e192b24SSimon Glass i = *llp; 5282e192b24SSimon Glass } 5292e192b24SSimon Glass #endif 5302e192b24SSimon Glass if (size == 4) { 5312e192b24SSimon Glass longp = (u32 *)buf; 5322e192b24SSimon Glass for (;;) 5332e192b24SSimon Glass i = *longp; 5342e192b24SSimon Glass } 5352e192b24SSimon Glass if (size == 2) { 5362e192b24SSimon Glass shortp = (u16 *)buf; 5372e192b24SSimon Glass for (;;) 5382e192b24SSimon Glass i = *shortp; 5392e192b24SSimon Glass } 5402e192b24SSimon Glass cp = (u8 *)buf; 5412e192b24SSimon Glass for (;;) 5422e192b24SSimon Glass i = *cp; 5432e192b24SSimon Glass } 5442e192b24SSimon Glass 5452e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 5462e192b24SSimon Glass if (size == 8) { 5472e192b24SSimon Glass for (;;) { 5482e192b24SSimon Glass llp = (u64 *)buf; 5492e192b24SSimon Glass i = length; 5502e192b24SSimon Glass while (i-- > 0) 5512e192b24SSimon Glass *llp++; 5522e192b24SSimon Glass } 5532e192b24SSimon Glass } 5542e192b24SSimon Glass #endif 5552e192b24SSimon Glass if (size == 4) { 5562e192b24SSimon Glass for (;;) { 5572e192b24SSimon Glass longp = (u32 *)buf; 5582e192b24SSimon Glass i = length; 5592e192b24SSimon Glass while (i-- > 0) 5602e192b24SSimon Glass *longp++; 5612e192b24SSimon Glass } 5622e192b24SSimon Glass } 5632e192b24SSimon Glass if (size == 2) { 5642e192b24SSimon Glass for (;;) { 5652e192b24SSimon Glass shortp = (u16 *)buf; 5662e192b24SSimon Glass i = length; 5672e192b24SSimon Glass while (i-- > 0) 5682e192b24SSimon Glass *shortp++; 5692e192b24SSimon Glass } 5702e192b24SSimon Glass } 5712e192b24SSimon Glass for (;;) { 5722e192b24SSimon Glass cp = (u8 *)buf; 5732e192b24SSimon Glass i = length; 5742e192b24SSimon Glass while (i-- > 0) 5752e192b24SSimon Glass *cp++; 5762e192b24SSimon Glass } 5772e192b24SSimon Glass unmap_sysmem(buf); 5782e192b24SSimon Glass 5792e192b24SSimon Glass return 0; 5802e192b24SSimon Glass } 5812e192b24SSimon Glass 5822e192b24SSimon Glass #ifdef CONFIG_LOOPW 5832e192b24SSimon Glass static int do_mem_loopw(cmd_tbl_t *cmdtp, int flag, int argc, 5842e192b24SSimon Glass char * const argv[]) 5852e192b24SSimon Glass { 5862e192b24SSimon Glass ulong addr, length, i, bytes; 5872e192b24SSimon Glass int size; 5882e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 5892e192b24SSimon Glass volatile u64 *llp; 5902e192b24SSimon Glass u64 data; 5912e192b24SSimon Glass #else 5922e192b24SSimon Glass ulong data; 5932e192b24SSimon Glass #endif 5942e192b24SSimon Glass volatile u32 *longp; 5952e192b24SSimon Glass volatile u16 *shortp; 5962e192b24SSimon Glass volatile u8 *cp; 5972e192b24SSimon Glass void *buf; 5982e192b24SSimon Glass 5992e192b24SSimon Glass if (argc < 4) 6002e192b24SSimon Glass return CMD_RET_USAGE; 6012e192b24SSimon Glass 6022e192b24SSimon Glass /* 6032e192b24SSimon Glass * Check for a size specification. 6042e192b24SSimon Glass * Defaults to long if no or incorrect specification. 6052e192b24SSimon Glass */ 6062e192b24SSimon Glass if ((size = cmd_get_data_size(argv[0], 4)) < 0) 6072e192b24SSimon Glass return 1; 6082e192b24SSimon Glass 6092e192b24SSimon Glass /* Address is always specified. 6102e192b24SSimon Glass */ 6112e192b24SSimon Glass addr = simple_strtoul(argv[1], NULL, 16); 6122e192b24SSimon Glass 6132e192b24SSimon Glass /* Length is the number of objects, not number of bytes. 6142e192b24SSimon Glass */ 6152e192b24SSimon Glass length = simple_strtoul(argv[2], NULL, 16); 6162e192b24SSimon Glass 6172e192b24SSimon Glass /* data to write */ 6182e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 6192e192b24SSimon Glass data = simple_strtoull(argv[3], NULL, 16); 6202e192b24SSimon Glass #else 6212e192b24SSimon Glass data = simple_strtoul(argv[3], NULL, 16); 6222e192b24SSimon Glass #endif 6232e192b24SSimon Glass 6242e192b24SSimon Glass bytes = size * length; 6252e192b24SSimon Glass buf = map_sysmem(addr, bytes); 6262e192b24SSimon Glass 6272e192b24SSimon Glass /* We want to optimize the loops to run as fast as possible. 6282e192b24SSimon Glass * If we have only one object, just run infinite loops. 6292e192b24SSimon Glass */ 6302e192b24SSimon Glass if (length == 1) { 6312e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 6322e192b24SSimon Glass if (size == 8) { 6332e192b24SSimon Glass llp = (u64 *)buf; 6342e192b24SSimon Glass for (;;) 6352e192b24SSimon Glass *llp = data; 6362e192b24SSimon Glass } 6372e192b24SSimon Glass #endif 6382e192b24SSimon Glass if (size == 4) { 6392e192b24SSimon Glass longp = (u32 *)buf; 6402e192b24SSimon Glass for (;;) 6412e192b24SSimon Glass *longp = data; 6422e192b24SSimon Glass } 6432e192b24SSimon Glass if (size == 2) { 6442e192b24SSimon Glass shortp = (u16 *)buf; 6452e192b24SSimon Glass for (;;) 6462e192b24SSimon Glass *shortp = data; 6472e192b24SSimon Glass } 6482e192b24SSimon Glass cp = (u8 *)buf; 6492e192b24SSimon Glass for (;;) 6502e192b24SSimon Glass *cp = data; 6512e192b24SSimon Glass } 6522e192b24SSimon Glass 6532e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 6542e192b24SSimon Glass if (size == 8) { 6552e192b24SSimon Glass for (;;) { 6562e192b24SSimon Glass llp = (u64 *)buf; 6572e192b24SSimon Glass i = length; 6582e192b24SSimon Glass while (i-- > 0) 6592e192b24SSimon Glass *llp++ = data; 6602e192b24SSimon Glass } 6612e192b24SSimon Glass } 6622e192b24SSimon Glass #endif 6632e192b24SSimon Glass if (size == 4) { 6642e192b24SSimon Glass for (;;) { 6652e192b24SSimon Glass longp = (u32 *)buf; 6662e192b24SSimon Glass i = length; 6672e192b24SSimon Glass while (i-- > 0) 6682e192b24SSimon Glass *longp++ = data; 6692e192b24SSimon Glass } 6702e192b24SSimon Glass } 6712e192b24SSimon Glass if (size == 2) { 6722e192b24SSimon Glass for (;;) { 6732e192b24SSimon Glass shortp = (u16 *)buf; 6742e192b24SSimon Glass i = length; 6752e192b24SSimon Glass while (i-- > 0) 6762e192b24SSimon Glass *shortp++ = data; 6772e192b24SSimon Glass } 6782e192b24SSimon Glass } 6792e192b24SSimon Glass for (;;) { 6802e192b24SSimon Glass cp = (u8 *)buf; 6812e192b24SSimon Glass i = length; 6822e192b24SSimon Glass while (i-- > 0) 6832e192b24SSimon Glass *cp++ = data; 6842e192b24SSimon Glass } 6852e192b24SSimon Glass } 6862e192b24SSimon Glass #endif /* CONFIG_LOOPW */ 6872e192b24SSimon Glass 6882e192b24SSimon Glass #ifdef CONFIG_CMD_MEMTEST 6892e192b24SSimon Glass static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr, 6902e192b24SSimon Glass vu_long *dummy) 6912e192b24SSimon Glass { 6922e192b24SSimon Glass vu_long *addr; 6932e192b24SSimon Glass ulong errs = 0; 6942e192b24SSimon Glass ulong val, readback; 6952e192b24SSimon Glass int j; 6962e192b24SSimon Glass vu_long offset; 6972e192b24SSimon Glass vu_long test_offset; 6982e192b24SSimon Glass vu_long pattern; 6992e192b24SSimon Glass vu_long temp; 7002e192b24SSimon Glass vu_long anti_pattern; 7012e192b24SSimon Glass vu_long num_words; 7022e192b24SSimon Glass static const ulong bitpattern[] = { 7032e192b24SSimon Glass 0x00000001, /* single bit */ 7042e192b24SSimon Glass 0x00000003, /* two adjacent bits */ 7052e192b24SSimon Glass 0x00000007, /* three adjacent bits */ 7062e192b24SSimon Glass 0x0000000F, /* four adjacent bits */ 7072e192b24SSimon Glass 0x00000005, /* two non-adjacent bits */ 7082e192b24SSimon Glass 0x00000015, /* three non-adjacent bits */ 7092e192b24SSimon Glass 0x00000055, /* four non-adjacent bits */ 7102e192b24SSimon Glass 0xaaaaaaaa, /* alternating 1/0 */ 7112e192b24SSimon Glass }; 7122e192b24SSimon Glass 7132e192b24SSimon Glass num_words = (end_addr - start_addr) / sizeof(vu_long); 7142e192b24SSimon Glass 7152e192b24SSimon Glass /* 7162e192b24SSimon Glass * Data line test: write a pattern to the first 7172e192b24SSimon Glass * location, write the 1's complement to a 'parking' 7182e192b24SSimon Glass * address (changes the state of the data bus so a 7192e192b24SSimon Glass * floating bus doesn't give a false OK), and then 7202e192b24SSimon Glass * read the value back. Note that we read it back 7212e192b24SSimon Glass * into a variable because the next time we read it, 7222e192b24SSimon Glass * it might be right (been there, tough to explain to 7232e192b24SSimon Glass * the quality guys why it prints a failure when the 7242e192b24SSimon Glass * "is" and "should be" are obviously the same in the 7252e192b24SSimon Glass * error message). 7262e192b24SSimon Glass * 7272e192b24SSimon Glass * Rather than exhaustively testing, we test some 7282e192b24SSimon Glass * patterns by shifting '1' bits through a field of 7292e192b24SSimon Glass * '0's and '0' bits through a field of '1's (i.e. 7302e192b24SSimon Glass * pattern and ~pattern). 7312e192b24SSimon Glass */ 7322e192b24SSimon Glass addr = buf; 7332e192b24SSimon Glass for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) { 7342e192b24SSimon Glass val = bitpattern[j]; 7352e192b24SSimon Glass for (; val != 0; val <<= 1) { 7362e192b24SSimon Glass *addr = val; 7372e192b24SSimon Glass *dummy = ~val; /* clear the test data off the bus */ 7382e192b24SSimon Glass readback = *addr; 7392e192b24SSimon Glass if (readback != val) { 7402e192b24SSimon Glass printf("FAILURE (data line): " 7412e192b24SSimon Glass "expected %08lx, actual %08lx\n", 7422e192b24SSimon Glass val, readback); 7432e192b24SSimon Glass errs++; 7442e192b24SSimon Glass if (ctrlc()) 7452e192b24SSimon Glass return -1; 7462e192b24SSimon Glass } 7472e192b24SSimon Glass *addr = ~val; 7482e192b24SSimon Glass *dummy = val; 7492e192b24SSimon Glass readback = *addr; 7502e192b24SSimon Glass if (readback != ~val) { 7512e192b24SSimon Glass printf("FAILURE (data line): " 7522e192b24SSimon Glass "Is %08lx, should be %08lx\n", 7532e192b24SSimon Glass readback, ~val); 7542e192b24SSimon Glass errs++; 7552e192b24SSimon Glass if (ctrlc()) 7562e192b24SSimon Glass return -1; 7572e192b24SSimon Glass } 7582e192b24SSimon Glass } 7592e192b24SSimon Glass } 7602e192b24SSimon Glass 7612e192b24SSimon Glass /* 7622e192b24SSimon Glass * Based on code whose Original Author and Copyright 7632e192b24SSimon Glass * information follows: Copyright (c) 1998 by Michael 7642e192b24SSimon Glass * Barr. This software is placed into the public 7652e192b24SSimon Glass * domain and may be used for any purpose. However, 7662e192b24SSimon Glass * this notice must not be changed or removed and no 7672e192b24SSimon Glass * warranty is either expressed or implied by its 7682e192b24SSimon Glass * publication or distribution. 7692e192b24SSimon Glass */ 7702e192b24SSimon Glass 7712e192b24SSimon Glass /* 7722e192b24SSimon Glass * Address line test 7732e192b24SSimon Glass 7742e192b24SSimon Glass * Description: Test the address bus wiring in a 7752e192b24SSimon Glass * memory region by performing a walking 7762e192b24SSimon Glass * 1's test on the relevant bits of the 7772e192b24SSimon Glass * address and checking for aliasing. 7782e192b24SSimon Glass * This test will find single-bit 7792e192b24SSimon Glass * address failures such as stuck-high, 7802e192b24SSimon Glass * stuck-low, and shorted pins. The base 7812e192b24SSimon Glass * address and size of the region are 7822e192b24SSimon Glass * selected by the caller. 7832e192b24SSimon Glass 7842e192b24SSimon Glass * Notes: For best results, the selected base 7852e192b24SSimon Glass * address should have enough LSB 0's to 7862e192b24SSimon Glass * guarantee single address bit changes. 7872e192b24SSimon Glass * For example, to test a 64-Kbyte 7882e192b24SSimon Glass * region, select a base address on a 7892e192b24SSimon Glass * 64-Kbyte boundary. Also, select the 7902e192b24SSimon Glass * region size as a power-of-two if at 7912e192b24SSimon Glass * all possible. 7922e192b24SSimon Glass * 7932e192b24SSimon Glass * Returns: 0 if the test succeeds, 1 if the test fails. 7942e192b24SSimon Glass */ 7952e192b24SSimon Glass pattern = (vu_long) 0xaaaaaaaa; 7962e192b24SSimon Glass anti_pattern = (vu_long) 0x55555555; 7972e192b24SSimon Glass 7982e192b24SSimon Glass debug("%s:%d: length = 0x%.8lx\n", __func__, __LINE__, num_words); 7992e192b24SSimon Glass /* 8002e192b24SSimon Glass * Write the default pattern at each of the 8012e192b24SSimon Glass * power-of-two offsets. 8022e192b24SSimon Glass */ 8032e192b24SSimon Glass for (offset = 1; offset < num_words; offset <<= 1) 8042e192b24SSimon Glass addr[offset] = pattern; 8052e192b24SSimon Glass 8062e192b24SSimon Glass /* 8072e192b24SSimon Glass * Check for address bits stuck high. 8082e192b24SSimon Glass */ 8092e192b24SSimon Glass test_offset = 0; 8102e192b24SSimon Glass addr[test_offset] = anti_pattern; 8112e192b24SSimon Glass 8122e192b24SSimon Glass for (offset = 1; offset < num_words; offset <<= 1) { 8132e192b24SSimon Glass temp = addr[offset]; 8142e192b24SSimon Glass if (temp != pattern) { 8152e192b24SSimon Glass printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:" 8162e192b24SSimon Glass " expected 0x%.8lx, actual 0x%.8lx\n", 8172e192b24SSimon Glass start_addr + offset*sizeof(vu_long), 8182e192b24SSimon Glass pattern, temp); 8192e192b24SSimon Glass errs++; 8202e192b24SSimon Glass if (ctrlc()) 8212e192b24SSimon Glass return -1; 8222e192b24SSimon Glass } 8232e192b24SSimon Glass } 8242e192b24SSimon Glass addr[test_offset] = pattern; 8252e192b24SSimon Glass WATCHDOG_RESET(); 8262e192b24SSimon Glass 8272e192b24SSimon Glass /* 8282e192b24SSimon Glass * Check for addr bits stuck low or shorted. 8292e192b24SSimon Glass */ 8302e192b24SSimon Glass for (test_offset = 1; test_offset < num_words; test_offset <<= 1) { 8312e192b24SSimon Glass addr[test_offset] = anti_pattern; 8322e192b24SSimon Glass 8332e192b24SSimon Glass for (offset = 1; offset < num_words; offset <<= 1) { 8342e192b24SSimon Glass temp = addr[offset]; 8352e192b24SSimon Glass if ((temp != pattern) && (offset != test_offset)) { 8362e192b24SSimon Glass printf("\nFAILURE: Address bit stuck low or" 8372e192b24SSimon Glass " shorted @ 0x%.8lx: expected 0x%.8lx," 8382e192b24SSimon Glass " actual 0x%.8lx\n", 8392e192b24SSimon Glass start_addr + offset*sizeof(vu_long), 8402e192b24SSimon Glass pattern, temp); 8412e192b24SSimon Glass errs++; 8422e192b24SSimon Glass if (ctrlc()) 8432e192b24SSimon Glass return -1; 8442e192b24SSimon Glass } 8452e192b24SSimon Glass } 8462e192b24SSimon Glass addr[test_offset] = pattern; 8472e192b24SSimon Glass } 8482e192b24SSimon Glass 8492e192b24SSimon Glass /* 8502e192b24SSimon Glass * Description: Test the integrity of a physical 8512e192b24SSimon Glass * memory device by performing an 8522e192b24SSimon Glass * increment/decrement test over the 8532e192b24SSimon Glass * entire region. In the process every 8542e192b24SSimon Glass * storage bit in the device is tested 8552e192b24SSimon Glass * as a zero and a one. The base address 8562e192b24SSimon Glass * and the size of the region are 8572e192b24SSimon Glass * selected by the caller. 8582e192b24SSimon Glass * 8592e192b24SSimon Glass * Returns: 0 if the test succeeds, 1 if the test fails. 8602e192b24SSimon Glass */ 8612e192b24SSimon Glass num_words++; 8622e192b24SSimon Glass 8632e192b24SSimon Glass /* 8642e192b24SSimon Glass * Fill memory with a known pattern. 8652e192b24SSimon Glass */ 8662e192b24SSimon Glass for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { 8672e192b24SSimon Glass WATCHDOG_RESET(); 8682e192b24SSimon Glass addr[offset] = pattern; 8692e192b24SSimon Glass } 8702e192b24SSimon Glass 8712e192b24SSimon Glass /* 8722e192b24SSimon Glass * Check each location and invert it for the second pass. 8732e192b24SSimon Glass */ 8742e192b24SSimon Glass for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { 8752e192b24SSimon Glass WATCHDOG_RESET(); 8762e192b24SSimon Glass temp = addr[offset]; 8772e192b24SSimon Glass if (temp != pattern) { 8782e192b24SSimon Glass printf("\nFAILURE (read/write) @ 0x%.8lx:" 8792e192b24SSimon Glass " expected 0x%.8lx, actual 0x%.8lx)\n", 8802e192b24SSimon Glass start_addr + offset*sizeof(vu_long), 8812e192b24SSimon Glass pattern, temp); 8822e192b24SSimon Glass errs++; 8832e192b24SSimon Glass if (ctrlc()) 8842e192b24SSimon Glass return -1; 8852e192b24SSimon Glass } 8862e192b24SSimon Glass 8872e192b24SSimon Glass anti_pattern = ~pattern; 8882e192b24SSimon Glass addr[offset] = anti_pattern; 8892e192b24SSimon Glass } 8902e192b24SSimon Glass 8912e192b24SSimon Glass /* 8922e192b24SSimon Glass * Check each location for the inverted pattern and zero it. 8932e192b24SSimon Glass */ 8942e192b24SSimon Glass for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { 8952e192b24SSimon Glass WATCHDOG_RESET(); 8962e192b24SSimon Glass anti_pattern = ~pattern; 8972e192b24SSimon Glass temp = addr[offset]; 8982e192b24SSimon Glass if (temp != anti_pattern) { 8992e192b24SSimon Glass printf("\nFAILURE (read/write): @ 0x%.8lx:" 9002e192b24SSimon Glass " expected 0x%.8lx, actual 0x%.8lx)\n", 9012e192b24SSimon Glass start_addr + offset*sizeof(vu_long), 9022e192b24SSimon Glass anti_pattern, temp); 9032e192b24SSimon Glass errs++; 9042e192b24SSimon Glass if (ctrlc()) 9052e192b24SSimon Glass return -1; 9062e192b24SSimon Glass } 9072e192b24SSimon Glass addr[offset] = 0; 9082e192b24SSimon Glass } 9092e192b24SSimon Glass 9102e192b24SSimon Glass return errs; 9112e192b24SSimon Glass } 9122e192b24SSimon Glass 9132e192b24SSimon Glass static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr, 9142e192b24SSimon Glass vu_long pattern, int iteration) 9152e192b24SSimon Glass { 9162e192b24SSimon Glass vu_long *end; 9172e192b24SSimon Glass vu_long *addr; 9182e192b24SSimon Glass ulong errs = 0; 9192e192b24SSimon Glass ulong incr, length; 9202e192b24SSimon Glass ulong val, readback; 9212e192b24SSimon Glass 9222e192b24SSimon Glass /* Alternate the pattern */ 9232e192b24SSimon Glass incr = 1; 9242e192b24SSimon Glass if (iteration & 1) { 9252e192b24SSimon Glass incr = -incr; 9262e192b24SSimon Glass /* 9272e192b24SSimon Glass * Flip the pattern each time to make lots of zeros and 9282e192b24SSimon Glass * then, the next time, lots of ones. We decrement 9292e192b24SSimon Glass * the "negative" patterns and increment the "positive" 9302e192b24SSimon Glass * patterns to preserve this feature. 9312e192b24SSimon Glass */ 9322e192b24SSimon Glass if (pattern & 0x80000000) 9332e192b24SSimon Glass pattern = -pattern; /* complement & increment */ 9342e192b24SSimon Glass else 9352e192b24SSimon Glass pattern = ~pattern; 9362e192b24SSimon Glass } 9372e192b24SSimon Glass length = (end_addr - start_addr) / sizeof(ulong); 9382e192b24SSimon Glass end = buf + length; 9392e192b24SSimon Glass printf("\rPattern %08lX Writing..." 9402e192b24SSimon Glass "%12s" 9412e192b24SSimon Glass "\b\b\b\b\b\b\b\b\b\b", 9422e192b24SSimon Glass pattern, ""); 9432e192b24SSimon Glass 9442e192b24SSimon Glass for (addr = buf, val = pattern; addr < end; addr++) { 9452e192b24SSimon Glass WATCHDOG_RESET(); 9462e192b24SSimon Glass *addr = val; 9472e192b24SSimon Glass val += incr; 9482e192b24SSimon Glass } 9492e192b24SSimon Glass 9502e192b24SSimon Glass puts("Reading..."); 9512e192b24SSimon Glass 9522e192b24SSimon Glass for (addr = buf, val = pattern; addr < end; addr++) { 9532e192b24SSimon Glass WATCHDOG_RESET(); 9542e192b24SSimon Glass readback = *addr; 9552e192b24SSimon Glass if (readback != val) { 9562e192b24SSimon Glass ulong offset = addr - buf; 9572e192b24SSimon Glass 9582e192b24SSimon Glass printf("\nMem error @ 0x%08X: " 9592e192b24SSimon Glass "found %08lX, expected %08lX\n", 9602e192b24SSimon Glass (uint)(uintptr_t)(start_addr + offset*sizeof(vu_long)), 9612e192b24SSimon Glass readback, val); 9622e192b24SSimon Glass errs++; 9632e192b24SSimon Glass if (ctrlc()) 9642e192b24SSimon Glass return -1; 9652e192b24SSimon Glass } 9662e192b24SSimon Glass val += incr; 9672e192b24SSimon Glass } 9682e192b24SSimon Glass 9692e192b24SSimon Glass return errs; 9702e192b24SSimon Glass } 9712e192b24SSimon Glass 9722e192b24SSimon Glass /* 9732e192b24SSimon Glass * Perform a memory test. A more complete alternative test can be 9742e192b24SSimon Glass * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until 9752e192b24SSimon Glass * interrupted by ctrl-c or by a failure of one of the sub-tests. 9762e192b24SSimon Glass */ 9772e192b24SSimon Glass static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc, 9782e192b24SSimon Glass char * const argv[]) 9792e192b24SSimon Glass { 9802e192b24SSimon Glass ulong start, end; 9812e192b24SSimon Glass vu_long *buf, *dummy; 9822e192b24SSimon Glass ulong iteration_limit = 0; 9832e192b24SSimon Glass int ret; 9842e192b24SSimon Glass ulong errs = 0; /* number of errors, or -1 if interrupted */ 9852e192b24SSimon Glass ulong pattern = 0; 9862e192b24SSimon Glass int iteration; 9872e192b24SSimon Glass #if defined(CONFIG_SYS_ALT_MEMTEST) 9882e192b24SSimon Glass const int alt_test = 1; 9892e192b24SSimon Glass #else 9902e192b24SSimon Glass const int alt_test = 0; 9912e192b24SSimon Glass #endif 9922e192b24SSimon Glass 9932e192b24SSimon Glass start = CONFIG_SYS_MEMTEST_START; 9942e192b24SSimon Glass end = CONFIG_SYS_MEMTEST_END; 9952e192b24SSimon Glass 9962e192b24SSimon Glass if (argc > 1) 9972e192b24SSimon Glass if (strict_strtoul(argv[1], 16, &start) < 0) 9982e192b24SSimon Glass return CMD_RET_USAGE; 9992e192b24SSimon Glass 10002e192b24SSimon Glass if (argc > 2) 10012e192b24SSimon Glass if (strict_strtoul(argv[2], 16, &end) < 0) 10022e192b24SSimon Glass return CMD_RET_USAGE; 10032e192b24SSimon Glass 10042e192b24SSimon Glass if (argc > 3) 10052e192b24SSimon Glass if (strict_strtoul(argv[3], 16, &pattern) < 0) 10062e192b24SSimon Glass return CMD_RET_USAGE; 10072e192b24SSimon Glass 10082e192b24SSimon Glass if (argc > 4) 10092e192b24SSimon Glass if (strict_strtoul(argv[4], 16, &iteration_limit) < 0) 10102e192b24SSimon Glass return CMD_RET_USAGE; 10112e192b24SSimon Glass 10122e192b24SSimon Glass if (end < start) { 10132e192b24SSimon Glass printf("Refusing to do empty test\n"); 10142e192b24SSimon Glass return -1; 10152e192b24SSimon Glass } 10162e192b24SSimon Glass 1017dfe461d6SMichal Simek printf("Testing %08lx ... %08lx:\n", start, end); 10182e192b24SSimon Glass debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__, 10192e192b24SSimon Glass start, end); 10202e192b24SSimon Glass 10212e192b24SSimon Glass buf = map_sysmem(start, end - start); 10222e192b24SSimon Glass dummy = map_sysmem(CONFIG_SYS_MEMTEST_SCRATCH, sizeof(vu_long)); 10232e192b24SSimon Glass for (iteration = 0; 10242e192b24SSimon Glass !iteration_limit || iteration < iteration_limit; 10252e192b24SSimon Glass iteration++) { 10262e192b24SSimon Glass if (ctrlc()) { 10272e192b24SSimon Glass errs = -1UL; 10282e192b24SSimon Glass break; 10292e192b24SSimon Glass } 10302e192b24SSimon Glass 10312e192b24SSimon Glass printf("Iteration: %6d\r", iteration + 1); 10322e192b24SSimon Glass debug("\n"); 10332e192b24SSimon Glass if (alt_test) { 10342e192b24SSimon Glass errs = mem_test_alt(buf, start, end, dummy); 10352e192b24SSimon Glass } else { 10362e192b24SSimon Glass errs = mem_test_quick(buf, start, end, pattern, 10372e192b24SSimon Glass iteration); 10382e192b24SSimon Glass } 10392e192b24SSimon Glass if (errs == -1UL) 10402e192b24SSimon Glass break; 10412e192b24SSimon Glass } 10422e192b24SSimon Glass 10432e192b24SSimon Glass /* 10442e192b24SSimon Glass * Work-around for eldk-4.2 which gives this warning if we try to 10452e192b24SSimon Glass * case in the unmap_sysmem() call: 10462e192b24SSimon Glass * warning: initialization discards qualifiers from pointer target type 10472e192b24SSimon Glass */ 10482e192b24SSimon Glass { 10492e192b24SSimon Glass void *vbuf = (void *)buf; 10502e192b24SSimon Glass void *vdummy = (void *)dummy; 10512e192b24SSimon Glass 10522e192b24SSimon Glass unmap_sysmem(vbuf); 10532e192b24SSimon Glass unmap_sysmem(vdummy); 10542e192b24SSimon Glass } 10552e192b24SSimon Glass 10562e192b24SSimon Glass if (errs == -1UL) { 10572e192b24SSimon Glass /* Memory test was aborted - write a newline to finish off */ 10582e192b24SSimon Glass putc('\n'); 10592e192b24SSimon Glass ret = 1; 10602e192b24SSimon Glass } else { 10612e192b24SSimon Glass printf("Tested %d iteration(s) with %lu errors.\n", 10622e192b24SSimon Glass iteration, errs); 10632e192b24SSimon Glass ret = errs != 0; 10642e192b24SSimon Glass } 10652e192b24SSimon Glass 10662e192b24SSimon Glass return ret; 10672e192b24SSimon Glass } 10682e192b24SSimon Glass #endif /* CONFIG_CMD_MEMTEST */ 10692e192b24SSimon Glass 10702e192b24SSimon Glass /* Modify memory. 10712e192b24SSimon Glass * 10722e192b24SSimon Glass * Syntax: 10732e192b24SSimon Glass * mm{.b, .w, .l, .q} {addr} 10742e192b24SSimon Glass * nm{.b, .w, .l, .q} {addr} 10752e192b24SSimon Glass */ 10762e192b24SSimon Glass static int 10772e192b24SSimon Glass mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[]) 10782e192b24SSimon Glass { 10792e192b24SSimon Glass ulong addr; 10802e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 10812e192b24SSimon Glass u64 i; 10822e192b24SSimon Glass #else 10832e192b24SSimon Glass ulong i; 10842e192b24SSimon Glass #endif 10852e192b24SSimon Glass int nbytes, size; 10862e192b24SSimon Glass void *ptr = NULL; 10872e192b24SSimon Glass 10882e192b24SSimon Glass if (argc != 2) 10892e192b24SSimon Glass return CMD_RET_USAGE; 10902e192b24SSimon Glass 10912e192b24SSimon Glass bootretry_reset_cmd_timeout(); /* got a good command to get here */ 10922e192b24SSimon Glass /* We use the last specified parameters, unless new ones are 10932e192b24SSimon Glass * entered. 10942e192b24SSimon Glass */ 10952e192b24SSimon Glass addr = mm_last_addr; 10962e192b24SSimon Glass size = mm_last_size; 10972e192b24SSimon Glass 10982e192b24SSimon Glass if ((flag & CMD_FLAG_REPEAT) == 0) { 10992e192b24SSimon Glass /* New command specified. Check for a size specification. 11002e192b24SSimon Glass * Defaults to long if no or incorrect specification. 11012e192b24SSimon Glass */ 11022e192b24SSimon Glass if ((size = cmd_get_data_size(argv[0], 4)) < 0) 11032e192b24SSimon Glass return 1; 11042e192b24SSimon Glass 11052e192b24SSimon Glass /* Address is specified since argc > 1 11062e192b24SSimon Glass */ 11072e192b24SSimon Glass addr = simple_strtoul(argv[1], NULL, 16); 11082e192b24SSimon Glass addr += base_address; 11092e192b24SSimon Glass } 11102e192b24SSimon Glass 11112e192b24SSimon Glass #ifdef CONFIG_HAS_DATAFLASH 11122e192b24SSimon Glass if (addr_dataflash(addr)){ 11132e192b24SSimon Glass puts ("Can't modify DataFlash in place. Use cp instead.\n\r"); 11142e192b24SSimon Glass return 0; 11152e192b24SSimon Glass } 11162e192b24SSimon Glass #endif 11172e192b24SSimon Glass 11182e192b24SSimon Glass #ifdef CONFIG_BLACKFIN 11192e192b24SSimon Glass if (addr_bfin_on_chip_mem(addr)) { 11202e192b24SSimon Glass puts ("Can't modify L1 instruction in place. Use cp instead.\n\r"); 11212e192b24SSimon Glass return 0; 11222e192b24SSimon Glass } 11232e192b24SSimon Glass #endif 11242e192b24SSimon Glass 11252e192b24SSimon Glass /* Print the address, followed by value. Then accept input for 11262e192b24SSimon Glass * the next value. A non-converted value exits. 11272e192b24SSimon Glass */ 11282e192b24SSimon Glass do { 11292e192b24SSimon Glass ptr = map_sysmem(addr, size); 11302e192b24SSimon Glass printf("%08lx:", addr); 11312e192b24SSimon Glass if (size == 4) 11322e192b24SSimon Glass printf(" %08x", *((u32 *)ptr)); 11332e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 11342e192b24SSimon Glass else if (size == 8) 11352e192b24SSimon Glass printf(" %016" PRIx64, *((u64 *)ptr)); 11362e192b24SSimon Glass #endif 11372e192b24SSimon Glass else if (size == 2) 11382e192b24SSimon Glass printf(" %04x", *((u16 *)ptr)); 11392e192b24SSimon Glass else 11402e192b24SSimon Glass printf(" %02x", *((u8 *)ptr)); 11412e192b24SSimon Glass 11422e192b24SSimon Glass nbytes = cli_readline(" ? "); 11432e192b24SSimon Glass if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) { 11442e192b24SSimon Glass /* <CR> pressed as only input, don't modify current 11452e192b24SSimon Glass * location and move to next. "-" pressed will go back. 11462e192b24SSimon Glass */ 11472e192b24SSimon Glass if (incrflag) 11482e192b24SSimon Glass addr += nbytes ? -size : size; 11492e192b24SSimon Glass nbytes = 1; 11502e192b24SSimon Glass /* good enough to not time out */ 11512e192b24SSimon Glass bootretry_reset_cmd_timeout(); 11522e192b24SSimon Glass } 11532e192b24SSimon Glass #ifdef CONFIG_BOOT_RETRY_TIME 11542e192b24SSimon Glass else if (nbytes == -2) { 11552e192b24SSimon Glass break; /* timed out, exit the command */ 11562e192b24SSimon Glass } 11572e192b24SSimon Glass #endif 11582e192b24SSimon Glass else { 11592e192b24SSimon Glass char *endp; 11602e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 11612e192b24SSimon Glass i = simple_strtoull(console_buffer, &endp, 16); 11622e192b24SSimon Glass #else 11632e192b24SSimon Glass i = simple_strtoul(console_buffer, &endp, 16); 11642e192b24SSimon Glass #endif 11652e192b24SSimon Glass nbytes = endp - console_buffer; 11662e192b24SSimon Glass if (nbytes) { 11672e192b24SSimon Glass /* good enough to not time out 11682e192b24SSimon Glass */ 11692e192b24SSimon Glass bootretry_reset_cmd_timeout(); 11702e192b24SSimon Glass if (size == 4) 11712e192b24SSimon Glass *((u32 *)ptr) = i; 11722e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 11732e192b24SSimon Glass else if (size == 8) 11742e192b24SSimon Glass *((u64 *)ptr) = i; 11752e192b24SSimon Glass #endif 11762e192b24SSimon Glass else if (size == 2) 11772e192b24SSimon Glass *((u16 *)ptr) = i; 11782e192b24SSimon Glass else 11792e192b24SSimon Glass *((u8 *)ptr) = i; 11802e192b24SSimon Glass if (incrflag) 11812e192b24SSimon Glass addr += size; 11822e192b24SSimon Glass } 11832e192b24SSimon Glass } 11842e192b24SSimon Glass } while (nbytes); 11852e192b24SSimon Glass if (ptr) 11862e192b24SSimon Glass unmap_sysmem(ptr); 11872e192b24SSimon Glass 11882e192b24SSimon Glass mm_last_addr = addr; 11892e192b24SSimon Glass mm_last_size = size; 11902e192b24SSimon Glass return 0; 11912e192b24SSimon Glass } 11922e192b24SSimon Glass 11932e192b24SSimon Glass #ifdef CONFIG_CMD_CRC32 11942e192b24SSimon Glass 11952e192b24SSimon Glass static int do_mem_crc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 11962e192b24SSimon Glass { 11972e192b24SSimon Glass int flags = 0; 11982e192b24SSimon Glass int ac; 11992e192b24SSimon Glass char * const *av; 12002e192b24SSimon Glass 12012e192b24SSimon Glass if (argc < 3) 12022e192b24SSimon Glass return CMD_RET_USAGE; 12032e192b24SSimon Glass 12042e192b24SSimon Glass av = argv + 1; 12052e192b24SSimon Glass ac = argc - 1; 12062e192b24SSimon Glass #ifdef CONFIG_HASH_VERIFY 12072e192b24SSimon Glass if (strcmp(*av, "-v") == 0) { 12082e192b24SSimon Glass flags |= HASH_FLAG_VERIFY | HASH_FLAG_ENV; 12092e192b24SSimon Glass av++; 12102e192b24SSimon Glass ac--; 12112e192b24SSimon Glass } 12122e192b24SSimon Glass #endif 12132e192b24SSimon Glass 12142e192b24SSimon Glass return hash_command("crc32", flags, cmdtp, flag, ac, av); 12152e192b24SSimon Glass } 12162e192b24SSimon Glass 12172e192b24SSimon Glass #endif 12182e192b24SSimon Glass 12192e192b24SSimon Glass /**************************************************/ 12202e192b24SSimon Glass U_BOOT_CMD( 12212e192b24SSimon Glass md, 3, 1, do_mem_md, 12222e192b24SSimon Glass "memory display", 12232e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 12242e192b24SSimon Glass "[.b, .w, .l, .q] address [# of objects]" 12252e192b24SSimon Glass #else 12262e192b24SSimon Glass "[.b, .w, .l] address [# of objects]" 12272e192b24SSimon Glass #endif 12282e192b24SSimon Glass ); 12292e192b24SSimon Glass 12302e192b24SSimon Glass 12312e192b24SSimon Glass U_BOOT_CMD( 12322e192b24SSimon Glass mm, 2, 1, do_mem_mm, 12332e192b24SSimon Glass "memory modify (auto-incrementing address)", 12342e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 12352e192b24SSimon Glass "[.b, .w, .l, .q] address" 12362e192b24SSimon Glass #else 12372e192b24SSimon Glass "[.b, .w, .l] address" 12382e192b24SSimon Glass #endif 12392e192b24SSimon Glass ); 12402e192b24SSimon Glass 12412e192b24SSimon Glass 12422e192b24SSimon Glass U_BOOT_CMD( 12432e192b24SSimon Glass nm, 2, 1, do_mem_nm, 12442e192b24SSimon Glass "memory modify (constant address)", 12452e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 12462e192b24SSimon Glass "[.b, .w, .l, .q] address" 12472e192b24SSimon Glass #else 12482e192b24SSimon Glass "[.b, .w, .l] address" 12492e192b24SSimon Glass #endif 12502e192b24SSimon Glass ); 12512e192b24SSimon Glass 12522e192b24SSimon Glass U_BOOT_CMD( 12532e192b24SSimon Glass mw, 4, 1, do_mem_mw, 12542e192b24SSimon Glass "memory write (fill)", 12552e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 12562e192b24SSimon Glass "[.b, .w, .l, .q] address value [count]" 12572e192b24SSimon Glass #else 12582e192b24SSimon Glass "[.b, .w, .l] address value [count]" 12592e192b24SSimon Glass #endif 12602e192b24SSimon Glass ); 12612e192b24SSimon Glass 12622e192b24SSimon Glass U_BOOT_CMD( 12632e192b24SSimon Glass cp, 4, 1, do_mem_cp, 12642e192b24SSimon Glass "memory copy", 12652e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 12662e192b24SSimon Glass "[.b, .w, .l, .q] source target count" 12672e192b24SSimon Glass #else 12682e192b24SSimon Glass "[.b, .w, .l] source target count" 12692e192b24SSimon Glass #endif 12702e192b24SSimon Glass ); 12712e192b24SSimon Glass 12722e192b24SSimon Glass U_BOOT_CMD( 12732e192b24SSimon Glass cmp, 4, 1, do_mem_cmp, 12742e192b24SSimon Glass "memory compare", 12752e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 12762e192b24SSimon Glass "[.b, .w, .l, .q] addr1 addr2 count" 12772e192b24SSimon Glass #else 12782e192b24SSimon Glass "[.b, .w, .l] addr1 addr2 count" 12792e192b24SSimon Glass #endif 12802e192b24SSimon Glass ); 12812e192b24SSimon Glass 12822e192b24SSimon Glass #ifdef CONFIG_CMD_CRC32 12832e192b24SSimon Glass 12842e192b24SSimon Glass #ifndef CONFIG_HASH_VERIFY 12852e192b24SSimon Glass 12862e192b24SSimon Glass U_BOOT_CMD( 12872e192b24SSimon Glass crc32, 4, 1, do_mem_crc, 12882e192b24SSimon Glass "checksum calculation", 12892e192b24SSimon Glass "address count [addr]\n - compute CRC32 checksum [save at addr]" 12902e192b24SSimon Glass ); 12912e192b24SSimon Glass 12922e192b24SSimon Glass #else /* CONFIG_HASH_VERIFY */ 12932e192b24SSimon Glass 12942e192b24SSimon Glass U_BOOT_CMD( 12952e192b24SSimon Glass crc32, 5, 1, do_mem_crc, 12962e192b24SSimon Glass "checksum calculation", 12972e192b24SSimon Glass "address count [addr]\n - compute CRC32 checksum [save at addr]\n" 12982e192b24SSimon Glass "-v address count crc\n - verify crc of memory area" 12992e192b24SSimon Glass ); 13002e192b24SSimon Glass 13012e192b24SSimon Glass #endif /* CONFIG_HASH_VERIFY */ 13022e192b24SSimon Glass 13032e192b24SSimon Glass #endif 13042e192b24SSimon Glass 13052e192b24SSimon Glass #ifdef CONFIG_CMD_MEMINFO 13062e192b24SSimon Glass __weak void board_show_dram(phys_size_t size) 13072e192b24SSimon Glass { 13082e192b24SSimon Glass puts("DRAM: "); 13092e192b24SSimon Glass print_size(size, "\n"); 13102e192b24SSimon Glass } 13112e192b24SSimon Glass 13122e192b24SSimon Glass static int do_mem_info(cmd_tbl_t *cmdtp, int flag, int argc, 13132e192b24SSimon Glass char * const argv[]) 13142e192b24SSimon Glass { 13152e192b24SSimon Glass board_show_dram(gd->ram_size); 13162e192b24SSimon Glass 13172e192b24SSimon Glass return 0; 13182e192b24SSimon Glass } 13192e192b24SSimon Glass #endif 13202e192b24SSimon Glass 13212e192b24SSimon Glass U_BOOT_CMD( 13222e192b24SSimon Glass base, 2, 1, do_mem_base, 13232e192b24SSimon Glass "print or set address offset", 13242e192b24SSimon Glass "\n - print address offset for memory commands\n" 13252e192b24SSimon Glass "base off\n - set address offset for memory commands to 'off'" 13262e192b24SSimon Glass ); 13272e192b24SSimon Glass 13282e192b24SSimon Glass U_BOOT_CMD( 13292e192b24SSimon Glass loop, 3, 1, do_mem_loop, 13302e192b24SSimon Glass "infinite loop on address range", 13312e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 13322e192b24SSimon Glass "[.b, .w, .l, .q] address number_of_objects" 13332e192b24SSimon Glass #else 13342e192b24SSimon Glass "[.b, .w, .l] address number_of_objects" 13352e192b24SSimon Glass #endif 13362e192b24SSimon Glass ); 13372e192b24SSimon Glass 13382e192b24SSimon Glass #ifdef CONFIG_LOOPW 13392e192b24SSimon Glass U_BOOT_CMD( 13402e192b24SSimon Glass loopw, 4, 1, do_mem_loopw, 13412e192b24SSimon Glass "infinite write loop on address range", 13422e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 13432e192b24SSimon Glass "[.b, .w, .l, .q] address number_of_objects data_to_write" 13442e192b24SSimon Glass #else 13452e192b24SSimon Glass "[.b, .w, .l] address number_of_objects data_to_write" 13462e192b24SSimon Glass #endif 13472e192b24SSimon Glass ); 13482e192b24SSimon Glass #endif /* CONFIG_LOOPW */ 13492e192b24SSimon Glass 13502e192b24SSimon Glass #ifdef CONFIG_CMD_MEMTEST 13512e192b24SSimon Glass U_BOOT_CMD( 13522e192b24SSimon Glass mtest, 5, 1, do_mem_mtest, 13532e192b24SSimon Glass "simple RAM read/write test", 13542e192b24SSimon Glass "[start [end [pattern [iterations]]]]" 13552e192b24SSimon Glass ); 13562e192b24SSimon Glass #endif /* CONFIG_CMD_MEMTEST */ 13572e192b24SSimon Glass 13582e192b24SSimon Glass #ifdef CONFIG_MX_CYCLIC 13592e192b24SSimon Glass U_BOOT_CMD( 13602e192b24SSimon Glass mdc, 4, 1, do_mem_mdc, 13612e192b24SSimon Glass "memory display cyclic", 13622e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 13632e192b24SSimon Glass "[.b, .w, .l, .q] address count delay(ms)" 13642e192b24SSimon Glass #else 13652e192b24SSimon Glass "[.b, .w, .l] address count delay(ms)" 13662e192b24SSimon Glass #endif 13672e192b24SSimon Glass ); 13682e192b24SSimon Glass 13692e192b24SSimon Glass U_BOOT_CMD( 13702e192b24SSimon Glass mwc, 4, 1, do_mem_mwc, 13712e192b24SSimon Glass "memory write cyclic", 13722e192b24SSimon Glass #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA 13732e192b24SSimon Glass "[.b, .w, .l, .q] address value delay(ms)" 13742e192b24SSimon Glass #else 13752e192b24SSimon Glass "[.b, .w, .l] address value delay(ms)" 13762e192b24SSimon Glass #endif 13772e192b24SSimon Glass ); 13782e192b24SSimon Glass #endif /* CONFIG_MX_CYCLIC */ 13792e192b24SSimon Glass 13802e192b24SSimon Glass #ifdef CONFIG_CMD_MEMINFO 13812e192b24SSimon Glass U_BOOT_CMD( 13822e192b24SSimon Glass meminfo, 3, 1, do_mem_info, 13832e192b24SSimon Glass "display memory information", 13842e192b24SSimon Glass "" 13852e192b24SSimon Glass ); 13862e192b24SSimon Glass #endif 1387