wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright 2000 |
| 3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
| 4 | * |
Wolfgang Denk | d79de1d | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 5 | * SPDX-License-Identifier: GPL-2.0+ |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
| 8 | /* |
| 9 | * Memory Functions |
| 10 | * |
| 11 | * Copied from FADS ROM, Dan Malek (dmalek@jlc.net) |
| 12 | */ |
| 13 | |
| 14 | #include <common.h> |
Simon Glass | 399ed9a | 2014-04-10 20:01:30 -0600 | [diff] [blame] | 15 | #include <bootretry.h> |
Simon Glass | dec3c01 | 2014-04-10 20:01:25 -0600 | [diff] [blame] | 16 | #include <cli.h> |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 17 | #include <command.h> |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 18 | #ifdef CONFIG_HAS_DATAFLASH |
| 19 | #include <dataflash.h> |
| 20 | #endif |
Simon Glass | 0bbd76f | 2013-02-24 20:30:22 +0000 | [diff] [blame] | 21 | #include <hash.h> |
Sergei Poselenov | 474dbb8 | 2008-04-09 16:09:41 +0200 | [diff] [blame] | 22 | #include <watchdog.h> |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 23 | #include <asm/io.h> |
Simon Glass | eacd14f | 2012-11-30 13:01:20 +0000 | [diff] [blame] | 24 | #include <linux/compiler.h> |
| 25 | |
| 26 | DECLARE_GLOBAL_DATA_PTR; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 27 | |
Simon Glass | 1c6c725 | 2013-02-24 17:33:29 +0000 | [diff] [blame] | 28 | #ifndef CONFIG_SYS_MEMTEST_SCRATCH |
| 29 | #define CONFIG_SYS_MEMTEST_SCRATCH 0 |
| 30 | #endif |
| 31 | |
Wolfgang Denk | 6262d021 | 2010-06-28 22:00:46 +0200 | [diff] [blame] | 32 | static int mod_mem(cmd_tbl_t *, int, int, int, char * const []); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 33 | |
| 34 | /* Display values from last command. |
| 35 | * Memory modify remembered values are different from display memory. |
| 36 | */ |
Mike Frysinger | 1a4af8c | 2010-12-22 09:40:29 -0500 | [diff] [blame] | 37 | static uint dp_last_addr, dp_last_size; |
| 38 | static uint dp_last_length = 0x40; |
| 39 | static uint mm_last_addr, mm_last_size; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 40 | |
| 41 | static ulong base_address = 0; |
| 42 | |
| 43 | /* Memory Display |
| 44 | * |
| 45 | * Syntax: |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 46 | * md{.b, .w, .l, .q} {addr} {len} |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 47 | */ |
| 48 | #define DISP_LINE_LEN 16 |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 49 | static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 50 | { |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 51 | ulong addr, length; |
Grant Likely | 02a0078 | 2007-02-20 09:05:00 +0100 | [diff] [blame] | 52 | #if defined(CONFIG_HAS_DATAFLASH) |
| 53 | ulong nbytes, linebytes; |
| 54 | #endif |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 55 | int size; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 56 | int rc = 0; |
| 57 | |
| 58 | /* We use the last specified parameters, unless new ones are |
| 59 | * entered. |
| 60 | */ |
| 61 | addr = dp_last_addr; |
| 62 | size = dp_last_size; |
| 63 | length = dp_last_length; |
| 64 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 65 | if (argc < 2) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 66 | return CMD_RET_USAGE; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 67 | |
| 68 | if ((flag & CMD_FLAG_REPEAT) == 0) { |
| 69 | /* New command specified. Check for a size specification. |
| 70 | * Defaults to long if no or incorrect specification. |
| 71 | */ |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 72 | if ((size = cmd_get_data_size(argv[0], 4)) < 0) |
| 73 | return 1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 74 | |
| 75 | /* Address is specified since argc > 1 |
| 76 | */ |
| 77 | addr = simple_strtoul(argv[1], NULL, 16); |
| 78 | addr += base_address; |
| 79 | |
| 80 | /* If another parameter, it is the length to display. |
| 81 | * Length is the number of objects, not number of bytes. |
| 82 | */ |
| 83 | if (argc > 2) |
| 84 | length = simple_strtoul(argv[2], NULL, 16); |
| 85 | } |
| 86 | |
Grant Likely | 02a0078 | 2007-02-20 09:05:00 +0100 | [diff] [blame] | 87 | #if defined(CONFIG_HAS_DATAFLASH) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 88 | /* Print the lines. |
| 89 | * |
| 90 | * We buffer all read data, so we can make sure data is read only |
| 91 | * once, and all accesses are with the specified bus width. |
| 92 | */ |
| 93 | nbytes = length * size; |
| 94 | do { |
| 95 | char linebuf[DISP_LINE_LEN]; |
Grant Likely | 02a0078 | 2007-02-20 09:05:00 +0100 | [diff] [blame] | 96 | void* p; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 97 | linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes; |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 98 | |
Grant Likely | 02a0078 | 2007-02-20 09:05:00 +0100 | [diff] [blame] | 99 | rc = read_dataflash(addr, (linebytes/size)*size, linebuf); |
| 100 | p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr; |
| 101 | print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size); |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 102 | |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 103 | nbytes -= linebytes; |
Grant Likely | 02a0078 | 2007-02-20 09:05:00 +0100 | [diff] [blame] | 104 | addr += linebytes; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 105 | if (ctrlc()) { |
| 106 | rc = 1; |
| 107 | break; |
| 108 | } |
| 109 | } while (nbytes > 0); |
Grant Likely | 02a0078 | 2007-02-20 09:05:00 +0100 | [diff] [blame] | 110 | #else |
Mike Frysinger | e578d68 | 2008-02-04 19:26:56 -0500 | [diff] [blame] | 111 | |
| 112 | # if defined(CONFIG_BLACKFIN) |
| 113 | /* See if we're trying to display L1 inst */ |
| 114 | if (addr_bfin_on_chip_mem(addr)) { |
| 115 | char linebuf[DISP_LINE_LEN]; |
| 116 | ulong linebytes, nbytes = length * size; |
| 117 | do { |
| 118 | linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes; |
| 119 | memcpy(linebuf, (void *)addr, linebytes); |
| 120 | print_buffer(addr, linebuf, size, linebytes/size, DISP_LINE_LEN/size); |
| 121 | |
| 122 | nbytes -= linebytes; |
| 123 | addr += linebytes; |
| 124 | if (ctrlc()) { |
| 125 | rc = 1; |
| 126 | break; |
| 127 | } |
| 128 | } while (nbytes > 0); |
| 129 | } else |
| 130 | # endif |
| 131 | |
| 132 | { |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 133 | ulong bytes = size * length; |
| 134 | const void *buf = map_sysmem(addr, bytes); |
| 135 | |
Mike Frysinger | e578d68 | 2008-02-04 19:26:56 -0500 | [diff] [blame] | 136 | /* Print the lines. */ |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 137 | print_buffer(addr, buf, size, length, DISP_LINE_LEN / size); |
| 138 | addr += bytes; |
| 139 | unmap_sysmem(buf); |
Mike Frysinger | e578d68 | 2008-02-04 19:26:56 -0500 | [diff] [blame] | 140 | } |
Grant Likely | 02a0078 | 2007-02-20 09:05:00 +0100 | [diff] [blame] | 141 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 142 | |
| 143 | dp_last_addr = addr; |
| 144 | dp_last_length = length; |
| 145 | dp_last_size = size; |
| 146 | return (rc); |
| 147 | } |
| 148 | |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 149 | static int do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 150 | { |
| 151 | return mod_mem (cmdtp, 1, flag, argc, argv); |
| 152 | } |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 153 | static int do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 154 | { |
| 155 | return mod_mem (cmdtp, 0, flag, argc, argv); |
| 156 | } |
| 157 | |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 158 | static int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 159 | { |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 160 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 161 | u64 writeval; |
| 162 | #else |
| 163 | ulong writeval; |
| 164 | #endif |
| 165 | ulong addr, count; |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 166 | int size; |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 167 | void *buf; |
| 168 | ulong bytes; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 169 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 170 | if ((argc < 3) || (argc > 4)) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 171 | return CMD_RET_USAGE; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 172 | |
| 173 | /* Check for size specification. |
| 174 | */ |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 175 | if ((size = cmd_get_data_size(argv[0], 4)) < 1) |
| 176 | return 1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 177 | |
| 178 | /* Address is specified since argc > 1 |
| 179 | */ |
| 180 | addr = simple_strtoul(argv[1], NULL, 16); |
| 181 | addr += base_address; |
| 182 | |
| 183 | /* Get the value to write. |
| 184 | */ |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 185 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 186 | writeval = simple_strtoull(argv[2], NULL, 16); |
| 187 | #else |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 188 | writeval = simple_strtoul(argv[2], NULL, 16); |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 189 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 190 | |
| 191 | /* Count ? */ |
| 192 | if (argc == 4) { |
| 193 | count = simple_strtoul(argv[3], NULL, 16); |
| 194 | } else { |
| 195 | count = 1; |
| 196 | } |
| 197 | |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 198 | bytes = size * count; |
| 199 | buf = map_sysmem(addr, bytes); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 200 | while (count-- > 0) { |
| 201 | if (size == 4) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 202 | *((u32 *)buf) = (u32)writeval; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 203 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 204 | else if (size == 8) |
| 205 | *((u64 *)buf) = (u64)writeval; |
| 206 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 207 | else if (size == 2) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 208 | *((u16 *)buf) = (u16)writeval; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 209 | else |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 210 | *((u8 *)buf) = (u8)writeval; |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 211 | buf += size; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 212 | } |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 213 | unmap_sysmem(buf); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 214 | return 0; |
| 215 | } |
| 216 | |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 217 | #ifdef CONFIG_MX_CYCLIC |
Masahiro Yamada | 0b2f331 | 2014-09-04 00:38:26 +0900 | [diff] [blame] | 218 | static int do_mem_mdc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 219 | { |
| 220 | int i; |
| 221 | ulong count; |
| 222 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 223 | if (argc < 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 224 | return CMD_RET_USAGE; |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 225 | |
| 226 | count = simple_strtoul(argv[3], NULL, 10); |
| 227 | |
| 228 | for (;;) { |
| 229 | do_mem_md (NULL, 0, 3, argv); |
| 230 | |
| 231 | /* delay for <count> ms... */ |
| 232 | for (i=0; i<count; i++) |
| 233 | udelay (1000); |
| 234 | |
| 235 | /* check for ctrl-c to abort... */ |
| 236 | if (ctrlc()) { |
| 237 | puts("Abort\n"); |
| 238 | return 0; |
| 239 | } |
| 240 | } |
| 241 | |
| 242 | return 0; |
| 243 | } |
| 244 | |
Masahiro Yamada | 0b2f331 | 2014-09-04 00:38:26 +0900 | [diff] [blame] | 245 | static int do_mem_mwc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 246 | { |
| 247 | int i; |
| 248 | ulong count; |
| 249 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 250 | if (argc < 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 251 | return CMD_RET_USAGE; |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 252 | |
| 253 | count = simple_strtoul(argv[3], NULL, 10); |
| 254 | |
| 255 | for (;;) { |
| 256 | do_mem_mw (NULL, 0, 3, argv); |
| 257 | |
| 258 | /* delay for <count> ms... */ |
| 259 | for (i=0; i<count; i++) |
| 260 | udelay (1000); |
| 261 | |
| 262 | /* check for ctrl-c to abort... */ |
| 263 | if (ctrlc()) { |
| 264 | puts("Abort\n"); |
| 265 | return 0; |
| 266 | } |
| 267 | } |
| 268 | |
| 269 | return 0; |
| 270 | } |
| 271 | #endif /* CONFIG_MX_CYCLIC */ |
| 272 | |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 273 | static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 274 | { |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 275 | ulong addr1, addr2, count, ngood, bytes; |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 276 | int size; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 277 | int rcode = 0; |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 278 | const char *type; |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 279 | const void *buf1, *buf2, *base; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 280 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 281 | u64 word1, word2; |
| 282 | #else |
| 283 | ulong word1, word2; |
| 284 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 285 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 286 | if (argc != 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 287 | return CMD_RET_USAGE; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 288 | |
| 289 | /* Check for size specification. |
| 290 | */ |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 291 | if ((size = cmd_get_data_size(argv[0], 4)) < 0) |
| 292 | return 1; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 293 | type = size == 8 ? "double word" : |
| 294 | size == 4 ? "word" : |
| 295 | size == 2 ? "halfword" : "byte"; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 296 | |
| 297 | addr1 = simple_strtoul(argv[1], NULL, 16); |
| 298 | addr1 += base_address; |
| 299 | |
| 300 | addr2 = simple_strtoul(argv[2], NULL, 16); |
| 301 | addr2 += base_address; |
| 302 | |
| 303 | count = simple_strtoul(argv[3], NULL, 16); |
| 304 | |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 305 | #ifdef CONFIG_HAS_DATAFLASH |
| 306 | if (addr_dataflash(addr1) | addr_dataflash(addr2)){ |
wdenk | 42c0547 | 2004-03-23 22:14:11 +0000 | [diff] [blame] | 307 | puts ("Comparison with DataFlash space not supported.\n\r"); |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 308 | return 0; |
| 309 | } |
| 310 | #endif |
| 311 | |
Mike Frysinger | e578d68 | 2008-02-04 19:26:56 -0500 | [diff] [blame] | 312 | #ifdef CONFIG_BLACKFIN |
| 313 | if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) { |
| 314 | puts ("Comparison with L1 instruction memory not supported.\n\r"); |
| 315 | return 0; |
| 316 | } |
| 317 | #endif |
| 318 | |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 319 | bytes = size * count; |
| 320 | base = buf1 = map_sysmem(addr1, bytes); |
| 321 | buf2 = map_sysmem(addr2, bytes); |
Mike Frysinger | a66afbd | 2012-01-20 09:07:22 +0000 | [diff] [blame] | 322 | for (ngood = 0; ngood < count; ++ngood) { |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 323 | if (size == 4) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 324 | word1 = *(u32 *)buf1; |
| 325 | word2 = *(u32 *)buf2; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 326 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 327 | } else if (size == 8) { |
| 328 | word1 = *(u64 *)buf1; |
| 329 | word2 = *(u64 *)buf2; |
| 330 | #endif |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 331 | } else if (size == 2) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 332 | word1 = *(u16 *)buf1; |
| 333 | word2 = *(u16 *)buf2; |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 334 | } else { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 335 | word1 = *(u8 *)buf1; |
| 336 | word2 = *(u8 *)buf2; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 337 | } |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 338 | if (word1 != word2) { |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 339 | ulong offset = buf1 - base; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 340 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 341 | printf("%s at 0x%p (%#0*llx) != %s at 0x%p (%#0*llx)\n", |
| 342 | type, (void *)(addr1 + offset), size, word1, |
| 343 | type, (void *)(addr2 + offset), size, word2); |
| 344 | #else |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 345 | printf("%s at 0x%08lx (%#0*lx) != %s at 0x%08lx (%#0*lx)\n", |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 346 | type, (ulong)(addr1 + offset), size, word1, |
| 347 | type, (ulong)(addr2 + offset), size, word2); |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 348 | #endif |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 349 | rcode = 1; |
| 350 | break; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 351 | } |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 352 | |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 353 | buf1 += size; |
| 354 | buf2 += size; |
Stefan Roese | d4ef82b | 2010-09-13 11:10:34 +0200 | [diff] [blame] | 355 | |
| 356 | /* reset watchdog from time to time */ |
Mike Frysinger | a66afbd | 2012-01-20 09:07:22 +0000 | [diff] [blame] | 357 | if ((ngood % (64 << 10)) == 0) |
Stefan Roese | d4ef82b | 2010-09-13 11:10:34 +0200 | [diff] [blame] | 358 | WATCHDOG_RESET(); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 359 | } |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 360 | unmap_sysmem(buf1); |
| 361 | unmap_sysmem(buf2); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 362 | |
Mike Frysinger | 62a7ea7 | 2012-01-20 09:07:21 +0000 | [diff] [blame] | 363 | printf("Total of %ld %s(s) were the same\n", ngood, type); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 364 | return rcode; |
| 365 | } |
| 366 | |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 367 | static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 368 | { |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 369 | ulong addr, dest, count, bytes; |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 370 | int size; |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 371 | const void *src; |
| 372 | void *buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 373 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 374 | if (argc != 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 375 | return CMD_RET_USAGE; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 376 | |
| 377 | /* Check for size specification. |
| 378 | */ |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 379 | if ((size = cmd_get_data_size(argv[0], 4)) < 0) |
| 380 | return 1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 381 | |
| 382 | addr = simple_strtoul(argv[1], NULL, 16); |
| 383 | addr += base_address; |
| 384 | |
| 385 | dest = simple_strtoul(argv[2], NULL, 16); |
| 386 | dest += base_address; |
| 387 | |
| 388 | count = simple_strtoul(argv[3], NULL, 16); |
| 389 | |
| 390 | if (count == 0) { |
| 391 | puts ("Zero length ???\n"); |
| 392 | return 1; |
| 393 | } |
| 394 | |
Jean-Christophe PLAGNIOL-VILLARD | 0383694 | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 395 | #ifndef CONFIG_SYS_NO_FLASH |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 396 | /* check if we are copying to Flash */ |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 397 | if ( (addr2info(dest) != NULL) |
| 398 | #ifdef CONFIG_HAS_DATAFLASH |
Kim B. Heino | 1eb0fd5 | 2008-03-03 10:39:13 +0200 | [diff] [blame] | 399 | && (!addr_dataflash(dest)) |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 400 | #endif |
| 401 | ) { |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 402 | int rc; |
| 403 | |
wdenk | 42c0547 | 2004-03-23 22:14:11 +0000 | [diff] [blame] | 404 | puts ("Copy to Flash... "); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 405 | |
Wolfgang Denk | 7fb5266 | 2005-10-13 16:45:02 +0200 | [diff] [blame] | 406 | rc = flash_write ((char *)addr, dest, count*size); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 407 | if (rc != 0) { |
| 408 | flash_perror (rc); |
| 409 | return (1); |
| 410 | } |
| 411 | puts ("done\n"); |
| 412 | return 0; |
| 413 | } |
| 414 | #endif |
| 415 | |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 416 | #ifdef CONFIG_HAS_DATAFLASH |
| 417 | /* Check if we are copying from RAM or Flash to DataFlash */ |
| 418 | if (addr_dataflash(dest) && !addr_dataflash(addr)){ |
| 419 | int rc; |
| 420 | |
wdenk | 42c0547 | 2004-03-23 22:14:11 +0000 | [diff] [blame] | 421 | puts ("Copy to DataFlash... "); |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 422 | |
| 423 | rc = write_dataflash (dest, addr, count*size); |
| 424 | |
| 425 | if (rc != 1) { |
| 426 | dataflash_perror (rc); |
| 427 | return (1); |
| 428 | } |
| 429 | puts ("done\n"); |
| 430 | return 0; |
| 431 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 432 | |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 433 | /* Check if we are copying from DataFlash to RAM */ |
Stelian Pop | a63d2eb | 2008-03-26 22:52:35 +0100 | [diff] [blame] | 434 | if (addr_dataflash(addr) && !addr_dataflash(dest) |
Jean-Christophe PLAGNIOL-VILLARD | 0383694 | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 435 | #ifndef CONFIG_SYS_NO_FLASH |
Stelian Pop | a63d2eb | 2008-03-26 22:52:35 +0100 | [diff] [blame] | 436 | && (addr2info(dest) == NULL) |
| 437 | #endif |
| 438 | ){ |
wdenk | 8676590 | 2003-12-06 23:55:10 +0000 | [diff] [blame] | 439 | int rc; |
| 440 | rc = read_dataflash(addr, count * size, (char *) dest); |
| 441 | if (rc != 1) { |
wdenk | 1ebf41e | 2004-01-02 14:00:00 +0000 | [diff] [blame] | 442 | dataflash_perror (rc); |
| 443 | return (1); |
| 444 | } |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 445 | return 0; |
| 446 | } |
| 447 | |
| 448 | if (addr_dataflash(addr) && addr_dataflash(dest)){ |
wdenk | 42c0547 | 2004-03-23 22:14:11 +0000 | [diff] [blame] | 449 | puts ("Unsupported combination of source/destination.\n\r"); |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 450 | return 1; |
| 451 | } |
wdenk | 7a428cc | 2003-06-15 22:40:42 +0000 | [diff] [blame] | 452 | #endif |
| 453 | |
Mike Frysinger | e578d68 | 2008-02-04 19:26:56 -0500 | [diff] [blame] | 454 | #ifdef CONFIG_BLACKFIN |
| 455 | /* See if we're copying to/from L1 inst */ |
| 456 | if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { |
| 457 | memcpy((void *)dest, (void *)addr, count * size); |
| 458 | return 0; |
| 459 | } |
| 460 | #endif |
| 461 | |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 462 | bytes = size * count; |
Masahiro Yamada | 4ad7dd5 | 2013-05-20 21:08:08 +0000 | [diff] [blame] | 463 | buf = map_sysmem(dest, bytes); |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 464 | src = map_sysmem(addr, bytes); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 465 | while (count-- > 0) { |
| 466 | if (size == 4) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 467 | *((u32 *)buf) = *((u32 *)src); |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 468 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 469 | else if (size == 8) |
| 470 | *((u64 *)buf) = *((u64 *)src); |
| 471 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 472 | else if (size == 2) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 473 | *((u16 *)buf) = *((u16 *)src); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 474 | else |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 475 | *((u8 *)buf) = *((u8 *)src); |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 476 | src += size; |
| 477 | buf += size; |
Stefan Roese | d4ef82b | 2010-09-13 11:10:34 +0200 | [diff] [blame] | 478 | |
| 479 | /* reset watchdog from time to time */ |
| 480 | if ((count % (64 << 10)) == 0) |
| 481 | WATCHDOG_RESET(); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 482 | } |
| 483 | return 0; |
| 484 | } |
| 485 | |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 486 | static int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc, |
| 487 | char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 488 | { |
| 489 | if (argc > 1) { |
| 490 | /* Set new base address. |
| 491 | */ |
| 492 | base_address = simple_strtoul(argv[1], NULL, 16); |
| 493 | } |
| 494 | /* Print the current base address. |
| 495 | */ |
| 496 | printf("Base Address: 0x%08lx\n", base_address); |
| 497 | return 0; |
| 498 | } |
| 499 | |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 500 | static int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc, |
| 501 | char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 502 | { |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 503 | ulong addr, length, i, bytes; |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 504 | int size; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 505 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 506 | volatile u64 *llp; |
| 507 | #endif |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 508 | volatile u32 *longp; |
| 509 | volatile u16 *shortp; |
| 510 | volatile u8 *cp; |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 511 | const void *buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 512 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 513 | if (argc < 3) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 514 | return CMD_RET_USAGE; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 515 | |
Robert P. J. Day | 21c9b78 | 2013-02-03 02:29:54 +0000 | [diff] [blame] | 516 | /* |
| 517 | * Check for a size specification. |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 518 | * Defaults to long if no or incorrect specification. |
| 519 | */ |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 520 | if ((size = cmd_get_data_size(argv[0], 4)) < 0) |
| 521 | return 1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 522 | |
| 523 | /* Address is always specified. |
| 524 | */ |
| 525 | addr = simple_strtoul(argv[1], NULL, 16); |
| 526 | |
| 527 | /* Length is the number of objects, not number of bytes. |
| 528 | */ |
| 529 | length = simple_strtoul(argv[2], NULL, 16); |
| 530 | |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 531 | bytes = size * length; |
| 532 | buf = map_sysmem(addr, bytes); |
| 533 | |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 534 | /* We want to optimize the loops to run as fast as possible. |
| 535 | * If we have only one object, just run infinite loops. |
| 536 | */ |
| 537 | if (length == 1) { |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 538 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 539 | if (size == 8) { |
| 540 | llp = (u64 *)buf; |
| 541 | for (;;) |
| 542 | i = *llp; |
| 543 | } |
| 544 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 545 | if (size == 4) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 546 | longp = (u32 *)buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 547 | for (;;) |
| 548 | i = *longp; |
| 549 | } |
| 550 | if (size == 2) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 551 | shortp = (u16 *)buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 552 | for (;;) |
| 553 | i = *shortp; |
| 554 | } |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 555 | cp = (u8 *)buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 556 | for (;;) |
| 557 | i = *cp; |
| 558 | } |
| 559 | |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 560 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 561 | if (size == 8) { |
| 562 | for (;;) { |
| 563 | llp = (u64 *)buf; |
| 564 | i = length; |
| 565 | while (i-- > 0) |
| 566 | *llp++; |
| 567 | } |
| 568 | } |
| 569 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 570 | if (size == 4) { |
| 571 | for (;;) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 572 | longp = (u32 *)buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 573 | i = length; |
| 574 | while (i-- > 0) |
Marek Vasut | 7d33582 | 2011-09-26 02:26:06 +0200 | [diff] [blame] | 575 | *longp++; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 576 | } |
| 577 | } |
| 578 | if (size == 2) { |
| 579 | for (;;) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 580 | shortp = (u16 *)buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 581 | i = length; |
| 582 | while (i-- > 0) |
Marek Vasut | 7d33582 | 2011-09-26 02:26:06 +0200 | [diff] [blame] | 583 | *shortp++; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 584 | } |
| 585 | } |
| 586 | for (;;) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 587 | cp = (u8 *)buf; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 588 | i = length; |
| 589 | while (i-- > 0) |
Marek Vasut | 7d33582 | 2011-09-26 02:26:06 +0200 | [diff] [blame] | 590 | *cp++; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 591 | } |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 592 | unmap_sysmem(buf); |
Simon Glass | 50d9eb9 | 2013-06-11 11:14:35 -0700 | [diff] [blame] | 593 | |
| 594 | return 0; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 595 | } |
| 596 | |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 597 | #ifdef CONFIG_LOOPW |
Masahiro Yamada | 0b2f331 | 2014-09-04 00:38:26 +0900 | [diff] [blame] | 598 | static int do_mem_loopw(cmd_tbl_t *cmdtp, int flag, int argc, |
| 599 | char * const argv[]) |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 600 | { |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 601 | ulong addr, length, i, bytes; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 602 | int size; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 603 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 604 | volatile u64 *llp; |
| 605 | u64 data; |
| 606 | #else |
| 607 | ulong data; |
| 608 | #endif |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 609 | volatile u32 *longp; |
| 610 | volatile u16 *shortp; |
| 611 | volatile u8 *cp; |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 612 | void *buf; |
wdenk | 7dd1329 | 2004-07-11 20:04:51 +0000 | [diff] [blame] | 613 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 614 | if (argc < 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 615 | return CMD_RET_USAGE; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 616 | |
Robert P. J. Day | 21c9b78 | 2013-02-03 02:29:54 +0000 | [diff] [blame] | 617 | /* |
| 618 | * Check for a size specification. |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 619 | * Defaults to long if no or incorrect specification. |
| 620 | */ |
| 621 | if ((size = cmd_get_data_size(argv[0], 4)) < 0) |
| 622 | return 1; |
| 623 | |
| 624 | /* Address is always specified. |
| 625 | */ |
| 626 | addr = simple_strtoul(argv[1], NULL, 16); |
| 627 | |
| 628 | /* Length is the number of objects, not number of bytes. |
| 629 | */ |
| 630 | length = simple_strtoul(argv[2], NULL, 16); |
| 631 | |
| 632 | /* data to write */ |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 633 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 634 | data = simple_strtoull(argv[3], NULL, 16); |
| 635 | #else |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 636 | data = simple_strtoul(argv[3], NULL, 16); |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 637 | #endif |
wdenk | 7dd1329 | 2004-07-11 20:04:51 +0000 | [diff] [blame] | 638 | |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 639 | bytes = size * length; |
| 640 | buf = map_sysmem(addr, bytes); |
| 641 | |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 642 | /* We want to optimize the loops to run as fast as possible. |
| 643 | * If we have only one object, just run infinite loops. |
| 644 | */ |
| 645 | if (length == 1) { |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 646 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 647 | if (size == 8) { |
| 648 | llp = (u64 *)buf; |
| 649 | for (;;) |
| 650 | *llp = data; |
| 651 | } |
| 652 | #endif |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 653 | if (size == 4) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 654 | longp = (u32 *)buf; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 655 | for (;;) |
| 656 | *longp = data; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 657 | } |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 658 | if (size == 2) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 659 | shortp = (u16 *)buf; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 660 | for (;;) |
| 661 | *shortp = data; |
| 662 | } |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 663 | cp = (u8 *)buf; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 664 | for (;;) |
| 665 | *cp = data; |
| 666 | } |
| 667 | |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 668 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 669 | if (size == 8) { |
| 670 | for (;;) { |
| 671 | llp = (u64 *)buf; |
| 672 | i = length; |
| 673 | while (i-- > 0) |
| 674 | *llp++ = data; |
| 675 | } |
| 676 | } |
| 677 | #endif |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 678 | if (size == 4) { |
| 679 | for (;;) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 680 | longp = (u32 *)buf; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 681 | i = length; |
| 682 | while (i-- > 0) |
| 683 | *longp++ = data; |
| 684 | } |
| 685 | } |
| 686 | if (size == 2) { |
| 687 | for (;;) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 688 | shortp = (u16 *)buf; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 689 | i = length; |
| 690 | while (i-- > 0) |
| 691 | *shortp++ = data; |
| 692 | } |
| 693 | } |
| 694 | for (;;) { |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 695 | cp = (u8 *)buf; |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 696 | i = length; |
| 697 | while (i-- > 0) |
| 698 | *cp++ = data; |
| 699 | } |
| 700 | } |
| 701 | #endif /* CONFIG_LOOPW */ |
| 702 | |
Tom Rini | a5f0270 | 2013-03-12 10:07:19 -0400 | [diff] [blame] | 703 | #ifdef CONFIG_CMD_MEMTEST |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 704 | static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr, |
| 705 | vu_long *dummy) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 706 | { |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 707 | vu_long *addr; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 708 | ulong errs = 0; |
| 709 | ulong val, readback; |
| 710 | int j; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 711 | vu_long offset; |
| 712 | vu_long test_offset; |
| 713 | vu_long pattern; |
| 714 | vu_long temp; |
| 715 | vu_long anti_pattern; |
| 716 | vu_long num_words; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 717 | static const ulong bitpattern[] = { |
| 718 | 0x00000001, /* single bit */ |
| 719 | 0x00000003, /* two adjacent bits */ |
| 720 | 0x00000007, /* three adjacent bits */ |
| 721 | 0x0000000F, /* four adjacent bits */ |
| 722 | 0x00000005, /* two non-adjacent bits */ |
| 723 | 0x00000015, /* three non-adjacent bits */ |
| 724 | 0x00000055, /* four non-adjacent bits */ |
| 725 | 0xaaaaaaaa, /* alternating 1/0 */ |
| 726 | }; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 727 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 728 | num_words = (end_addr - start_addr) / sizeof(vu_long); |
Simon Glass | 5107525 | 2013-02-24 17:33:20 +0000 | [diff] [blame] | 729 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 730 | /* |
| 731 | * Data line test: write a pattern to the first |
| 732 | * location, write the 1's complement to a 'parking' |
| 733 | * address (changes the state of the data bus so a |
| 734 | * floating bus doesn't give a false OK), and then |
| 735 | * read the value back. Note that we read it back |
| 736 | * into a variable because the next time we read it, |
| 737 | * it might be right (been there, tough to explain to |
| 738 | * the quality guys why it prints a failure when the |
| 739 | * "is" and "should be" are obviously the same in the |
| 740 | * error message). |
| 741 | * |
| 742 | * Rather than exhaustively testing, we test some |
| 743 | * patterns by shifting '1' bits through a field of |
| 744 | * '0's and '0' bits through a field of '1's (i.e. |
| 745 | * pattern and ~pattern). |
| 746 | */ |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 747 | addr = buf; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 748 | for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) { |
| 749 | val = bitpattern[j]; |
| 750 | for (; val != 0; val <<= 1) { |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 751 | *addr = val; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 752 | *dummy = ~val; /* clear the test data off the bus */ |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 753 | readback = *addr; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 754 | if (readback != val) { |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 755 | printf("FAILURE (data line): " |
| 756 | "expected %08lx, actual %08lx\n", |
| 757 | val, readback); |
| 758 | errs++; |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 759 | if (ctrlc()) |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 760 | return -1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 761 | } |
| 762 | *addr = ~val; |
| 763 | *dummy = val; |
| 764 | readback = *addr; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 765 | if (readback != ~val) { |
| 766 | printf("FAILURE (data line): " |
| 767 | "Is %08lx, should be %08lx\n", |
| 768 | readback, ~val); |
| 769 | errs++; |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 770 | if (ctrlc()) |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 771 | return -1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 772 | } |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 773 | } |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 774 | } |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 775 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 776 | /* |
| 777 | * Based on code whose Original Author and Copyright |
| 778 | * information follows: Copyright (c) 1998 by Michael |
| 779 | * Barr. This software is placed into the public |
| 780 | * domain and may be used for any purpose. However, |
| 781 | * this notice must not be changed or removed and no |
| 782 | * warranty is either expressed or implied by its |
| 783 | * publication or distribution. |
| 784 | */ |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 785 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 786 | /* |
| 787 | * Address line test |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 788 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 789 | * Description: Test the address bus wiring in a |
| 790 | * memory region by performing a walking |
| 791 | * 1's test on the relevant bits of the |
| 792 | * address and checking for aliasing. |
| 793 | * This test will find single-bit |
| 794 | * address failures such as stuck-high, |
| 795 | * stuck-low, and shorted pins. The base |
| 796 | * address and size of the region are |
| 797 | * selected by the caller. |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 798 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 799 | * Notes: For best results, the selected base |
| 800 | * address should have enough LSB 0's to |
| 801 | * guarantee single address bit changes. |
| 802 | * For example, to test a 64-Kbyte |
| 803 | * region, select a base address on a |
| 804 | * 64-Kbyte boundary. Also, select the |
| 805 | * region size as a power-of-two if at |
| 806 | * all possible. |
| 807 | * |
| 808 | * Returns: 0 if the test succeeds, 1 if the test fails. |
| 809 | */ |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 810 | pattern = (vu_long) 0xaaaaaaaa; |
| 811 | anti_pattern = (vu_long) 0x55555555; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 812 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 813 | debug("%s:%d: length = 0x%.8lx\n", __func__, __LINE__, num_words); |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 814 | /* |
| 815 | * Write the default pattern at each of the |
| 816 | * power-of-two offsets. |
| 817 | */ |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 818 | for (offset = 1; offset < num_words; offset <<= 1) |
| 819 | addr[offset] = pattern; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 820 | |
| 821 | /* |
| 822 | * Check for address bits stuck high. |
| 823 | */ |
| 824 | test_offset = 0; |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 825 | addr[test_offset] = anti_pattern; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 826 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 827 | for (offset = 1; offset < num_words; offset <<= 1) { |
| 828 | temp = addr[offset]; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 829 | if (temp != pattern) { |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 830 | printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:" |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 831 | " expected 0x%.8lx, actual 0x%.8lx\n", |
David Feng | f40b221 | 2014-02-12 16:10:08 +0800 | [diff] [blame] | 832 | start_addr + offset*sizeof(vu_long), |
| 833 | pattern, temp); |
Paul Gortmaker | cb47b4f | 2009-10-02 18:18:33 -0400 | [diff] [blame] | 834 | errs++; |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 835 | if (ctrlc()) |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 836 | return -1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 837 | } |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 838 | } |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 839 | addr[test_offset] = pattern; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 840 | WATCHDOG_RESET(); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 841 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 842 | /* |
| 843 | * Check for addr bits stuck low or shorted. |
| 844 | */ |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 845 | for (test_offset = 1; test_offset < num_words; test_offset <<= 1) { |
| 846 | addr[test_offset] = anti_pattern; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 847 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 848 | for (offset = 1; offset < num_words; offset <<= 1) { |
| 849 | temp = addr[offset]; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 850 | if ((temp != pattern) && (offset != test_offset)) { |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 851 | printf("\nFAILURE: Address bit stuck low or" |
| 852 | " shorted @ 0x%.8lx: expected 0x%.8lx," |
| 853 | " actual 0x%.8lx\n", |
David Feng | f40b221 | 2014-02-12 16:10:08 +0800 | [diff] [blame] | 854 | start_addr + offset*sizeof(vu_long), |
| 855 | pattern, temp); |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 856 | errs++; |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 857 | if (ctrlc()) |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 858 | return -1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 859 | } |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 860 | } |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 861 | addr[test_offset] = pattern; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 862 | } |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 863 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 864 | /* |
| 865 | * Description: Test the integrity of a physical |
| 866 | * memory device by performing an |
| 867 | * increment/decrement test over the |
| 868 | * entire region. In the process every |
| 869 | * storage bit in the device is tested |
| 870 | * as a zero and a one. The base address |
| 871 | * and the size of the region are |
| 872 | * selected by the caller. |
| 873 | * |
| 874 | * Returns: 0 if the test succeeds, 1 if the test fails. |
| 875 | */ |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 876 | num_words++; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 877 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 878 | /* |
| 879 | * Fill memory with a known pattern. |
| 880 | */ |
| 881 | for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { |
| 882 | WATCHDOG_RESET(); |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 883 | addr[offset] = pattern; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 884 | } |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 885 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 886 | /* |
| 887 | * Check each location and invert it for the second pass. |
| 888 | */ |
| 889 | for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { |
| 890 | WATCHDOG_RESET(); |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 891 | temp = addr[offset]; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 892 | if (temp != pattern) { |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 893 | printf("\nFAILURE (read/write) @ 0x%.8lx:" |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 894 | " expected 0x%.8lx, actual 0x%.8lx)\n", |
David Feng | f40b221 | 2014-02-12 16:10:08 +0800 | [diff] [blame] | 895 | start_addr + offset*sizeof(vu_long), |
| 896 | pattern, temp); |
Paul Gortmaker | cb47b4f | 2009-10-02 18:18:33 -0400 | [diff] [blame] | 897 | errs++; |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 898 | if (ctrlc()) |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 899 | return -1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 900 | } |
| 901 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 902 | anti_pattern = ~pattern; |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 903 | addr[offset] = anti_pattern; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 904 | } |
| 905 | |
| 906 | /* |
| 907 | * Check each location for the inverted pattern and zero it. |
| 908 | */ |
| 909 | for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) { |
| 910 | WATCHDOG_RESET(); |
| 911 | anti_pattern = ~pattern; |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 912 | temp = addr[offset]; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 913 | if (temp != anti_pattern) { |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 914 | printf("\nFAILURE (read/write): @ 0x%.8lx:" |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 915 | " expected 0x%.8lx, actual 0x%.8lx)\n", |
David Feng | f40b221 | 2014-02-12 16:10:08 +0800 | [diff] [blame] | 916 | start_addr + offset*sizeof(vu_long), |
| 917 | anti_pattern, temp); |
Paul Gortmaker | cb47b4f | 2009-10-02 18:18:33 -0400 | [diff] [blame] | 918 | errs++; |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 919 | if (ctrlc()) |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 920 | return -1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 921 | } |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 922 | addr[offset] = 0; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 923 | } |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 924 | |
| 925 | return 0; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 926 | } |
| 927 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 928 | static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr, |
| 929 | vu_long pattern, int iteration) |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 930 | { |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 931 | vu_long *end; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 932 | vu_long *addr; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 933 | ulong errs = 0; |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 934 | ulong incr, length; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 935 | ulong val, readback; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 936 | |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 937 | /* Alternate the pattern */ |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 938 | incr = 1; |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 939 | if (iteration & 1) { |
| 940 | incr = -incr; |
| 941 | /* |
| 942 | * Flip the pattern each time to make lots of zeros and |
| 943 | * then, the next time, lots of ones. We decrement |
| 944 | * the "negative" patterns and increment the "positive" |
| 945 | * patterns to preserve this feature. |
| 946 | */ |
| 947 | if (pattern & 0x80000000) |
| 948 | pattern = -pattern; /* complement & increment */ |
| 949 | else |
| 950 | pattern = ~pattern; |
| 951 | } |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 952 | length = (end_addr - start_addr) / sizeof(ulong); |
| 953 | end = buf + length; |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 954 | printf("\rPattern %08lX Writing..." |
| 955 | "%12s" |
| 956 | "\b\b\b\b\b\b\b\b\b\b", |
| 957 | pattern, ""); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 958 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 959 | for (addr = buf, val = pattern; addr < end; addr++) { |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 960 | WATCHDOG_RESET(); |
| 961 | *addr = val; |
| 962 | val += incr; |
| 963 | } |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 964 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 965 | puts("Reading..."); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 966 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 967 | for (addr = buf, val = pattern; addr < end; addr++) { |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 968 | WATCHDOG_RESET(); |
| 969 | readback = *addr; |
| 970 | if (readback != val) { |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 971 | ulong offset = addr - buf; |
| 972 | |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 973 | printf("\nMem error @ 0x%08X: " |
| 974 | "found %08lX, expected %08lX\n", |
David Feng | f40b221 | 2014-02-12 16:10:08 +0800 | [diff] [blame] | 975 | (uint)(uintptr_t)(start_addr + offset*sizeof(vu_long)), |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 976 | readback, val); |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 977 | errs++; |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 978 | if (ctrlc()) |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 979 | return -1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 980 | } |
Simon Glass | 130103e | 2013-02-24 17:33:18 +0000 | [diff] [blame] | 981 | val += incr; |
| 982 | } |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 983 | |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 984 | return 0; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 985 | } |
| 986 | |
| 987 | /* |
| 988 | * Perform a memory test. A more complete alternative test can be |
| 989 | * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until |
| 990 | * interrupted by ctrl-c or by a failure of one of the sub-tests. |
| 991 | */ |
| 992 | static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc, |
| 993 | char * const argv[]) |
| 994 | { |
Simon Glass | 5107525 | 2013-02-24 17:33:20 +0000 | [diff] [blame] | 995 | ulong start, end; |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 996 | vu_long *buf, *dummy; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 997 | int iteration_limit; |
| 998 | int ret; |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 999 | ulong errs = 0; /* number of errors, or -1 if interrupted */ |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1000 | ulong pattern; |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 1001 | int iteration; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1002 | #if defined(CONFIG_SYS_ALT_MEMTEST) |
| 1003 | const int alt_test = 1; |
| 1004 | #else |
| 1005 | const int alt_test = 0; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1006 | #endif |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1007 | |
| 1008 | if (argc > 1) |
Simon Glass | 5107525 | 2013-02-24 17:33:20 +0000 | [diff] [blame] | 1009 | start = simple_strtoul(argv[1], NULL, 16); |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1010 | else |
Simon Glass | 5107525 | 2013-02-24 17:33:20 +0000 | [diff] [blame] | 1011 | start = CONFIG_SYS_MEMTEST_START; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1012 | |
| 1013 | if (argc > 2) |
Simon Glass | 5107525 | 2013-02-24 17:33:20 +0000 | [diff] [blame] | 1014 | end = simple_strtoul(argv[2], NULL, 16); |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1015 | else |
Simon Glass | 5107525 | 2013-02-24 17:33:20 +0000 | [diff] [blame] | 1016 | end = CONFIG_SYS_MEMTEST_END; |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1017 | |
| 1018 | if (argc > 3) |
| 1019 | pattern = (ulong)simple_strtoul(argv[3], NULL, 16); |
| 1020 | else |
| 1021 | pattern = 0; |
| 1022 | |
| 1023 | if (argc > 4) |
| 1024 | iteration_limit = (ulong)simple_strtoul(argv[4], NULL, 16); |
| 1025 | else |
| 1026 | iteration_limit = 0; |
| 1027 | |
Simon Glass | 5107525 | 2013-02-24 17:33:20 +0000 | [diff] [blame] | 1028 | printf("Testing %08x ... %08x:\n", (uint)start, (uint)end); |
| 1029 | debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__, |
| 1030 | start, end); |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 1031 | |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 1032 | buf = map_sysmem(start, end - start); |
| 1033 | dummy = map_sysmem(CONFIG_SYS_MEMTEST_SCRATCH, sizeof(vu_long)); |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 1034 | for (iteration = 0; |
| 1035 | !iteration_limit || iteration < iteration_limit; |
| 1036 | iteration++) { |
| 1037 | if (ctrlc()) { |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 1038 | errs = -1UL; |
| 1039 | break; |
| 1040 | } |
| 1041 | |
| 1042 | printf("Iteration: %6d\r", iteration + 1); |
| 1043 | debug("\n"); |
Simon Glass | ad02a01 | 2013-02-28 17:47:14 +0000 | [diff] [blame] | 1044 | if (alt_test) { |
| 1045 | errs = mem_test_alt(buf, start, end, dummy); |
| 1046 | } else { |
| 1047 | errs = mem_test_quick(buf, start, end, pattern, |
| 1048 | iteration); |
| 1049 | } |
| 1050 | if (errs == -1UL) |
| 1051 | break; |
| 1052 | } |
| 1053 | |
| 1054 | /* |
| 1055 | * Work-around for eldk-4.2 which gives this warning if we try to |
| 1056 | * case in the unmap_sysmem() call: |
| 1057 | * warning: initialization discards qualifiers from pointer target type |
| 1058 | */ |
| 1059 | { |
| 1060 | void *vbuf = (void *)buf; |
| 1061 | void *vdummy = (void *)dummy; |
| 1062 | |
| 1063 | unmap_sysmem(vbuf); |
| 1064 | unmap_sysmem(vdummy); |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 1065 | } |
| 1066 | |
| 1067 | if (errs == -1UL) { |
Simon Glass | eb4598b | 2013-02-24 17:33:19 +0000 | [diff] [blame] | 1068 | /* Memory test was aborted - write a newline to finish off */ |
| 1069 | putc('\n'); |
Simon Glass | 57ee443 | 2013-02-24 17:33:17 +0000 | [diff] [blame] | 1070 | ret = 1; |
| 1071 | } else { |
| 1072 | printf("Tested %d iteration(s) with %lu errors.\n", |
| 1073 | iteration, errs); |
| 1074 | ret = errs != 0; |
| 1075 | } |
Simon Glass | 8f2c758 | 2013-02-24 17:33:16 +0000 | [diff] [blame] | 1076 | |
| 1077 | return ret; /* not reached */ |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1078 | } |
Wolfgang Denk | 9d00928 | 2013-03-08 10:51:32 +0000 | [diff] [blame] | 1079 | #endif /* CONFIG_CMD_MEMTEST */ |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1080 | |
| 1081 | /* Modify memory. |
| 1082 | * |
| 1083 | * Syntax: |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1084 | * mm{.b, .w, .l, .q} {addr} |
| 1085 | * nm{.b, .w, .l, .q} {addr} |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1086 | */ |
| 1087 | static int |
Wolfgang Denk | 6262d021 | 2010-06-28 22:00:46 +0200 | [diff] [blame] | 1088 | mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1089 | { |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1090 | ulong addr; |
| 1091 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1092 | u64 i; |
| 1093 | #else |
| 1094 | ulong i; |
| 1095 | #endif |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 1096 | int nbytes, size; |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 1097 | void *ptr = NULL; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1098 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 1099 | if (argc != 2) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 1100 | return CMD_RET_USAGE; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1101 | |
Simon Glass | 09007c4 | 2014-04-10 20:01:31 -0600 | [diff] [blame] | 1102 | bootretry_reset_cmd_timeout(); /* got a good command to get here */ |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1103 | /* We use the last specified parameters, unless new ones are |
| 1104 | * entered. |
| 1105 | */ |
| 1106 | addr = mm_last_addr; |
| 1107 | size = mm_last_size; |
| 1108 | |
| 1109 | if ((flag & CMD_FLAG_REPEAT) == 0) { |
| 1110 | /* New command specified. Check for a size specification. |
| 1111 | * Defaults to long if no or incorrect specification. |
| 1112 | */ |
wdenk | 874ac26 | 2003-07-24 23:38:38 +0000 | [diff] [blame] | 1113 | if ((size = cmd_get_data_size(argv[0], 4)) < 0) |
| 1114 | return 1; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1115 | |
| 1116 | /* Address is specified since argc > 1 |
| 1117 | */ |
| 1118 | addr = simple_strtoul(argv[1], NULL, 16); |
| 1119 | addr += base_address; |
| 1120 | } |
| 1121 | |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 1122 | #ifdef CONFIG_HAS_DATAFLASH |
| 1123 | if (addr_dataflash(addr)){ |
wdenk | 42c0547 | 2004-03-23 22:14:11 +0000 | [diff] [blame] | 1124 | puts ("Can't modify DataFlash in place. Use cp instead.\n\r"); |
wdenk | 381669a | 2003-06-16 23:50:08 +0000 | [diff] [blame] | 1125 | return 0; |
| 1126 | } |
| 1127 | #endif |
| 1128 | |
Mike Frysinger | e578d68 | 2008-02-04 19:26:56 -0500 | [diff] [blame] | 1129 | #ifdef CONFIG_BLACKFIN |
| 1130 | if (addr_bfin_on_chip_mem(addr)) { |
| 1131 | puts ("Can't modify L1 instruction in place. Use cp instead.\n\r"); |
| 1132 | return 0; |
| 1133 | } |
| 1134 | #endif |
| 1135 | |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1136 | /* Print the address, followed by value. Then accept input for |
| 1137 | * the next value. A non-converted value exits. |
| 1138 | */ |
| 1139 | do { |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 1140 | ptr = map_sysmem(addr, size); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1141 | printf("%08lx:", addr); |
| 1142 | if (size == 4) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 1143 | printf(" %08x", *((u32 *)ptr)); |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1144 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1145 | else if (size == 8) |
| 1146 | printf(" %016llx", *((u64 *)ptr)); |
| 1147 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1148 | else if (size == 2) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 1149 | printf(" %04x", *((u16 *)ptr)); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1150 | else |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 1151 | printf(" %02x", *((u8 *)ptr)); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1152 | |
Simon Glass | be6aafc | 2014-04-10 20:01:27 -0600 | [diff] [blame] | 1153 | nbytes = cli_readline(" ? "); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1154 | if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) { |
| 1155 | /* <CR> pressed as only input, don't modify current |
| 1156 | * location and move to next. "-" pressed will go back. |
| 1157 | */ |
| 1158 | if (incrflag) |
| 1159 | addr += nbytes ? -size : size; |
| 1160 | nbytes = 1; |
Simon Glass | 09007c4 | 2014-04-10 20:01:31 -0600 | [diff] [blame] | 1161 | /* good enough to not time out */ |
| 1162 | bootretry_reset_cmd_timeout(); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1163 | } |
| 1164 | #ifdef CONFIG_BOOT_RETRY_TIME |
| 1165 | else if (nbytes == -2) { |
| 1166 | break; /* timed out, exit the command */ |
| 1167 | } |
| 1168 | #endif |
| 1169 | else { |
| 1170 | char *endp; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1171 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1172 | i = simple_strtoull(console_buffer, &endp, 16); |
| 1173 | #else |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1174 | i = simple_strtoul(console_buffer, &endp, 16); |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1175 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1176 | nbytes = endp - console_buffer; |
| 1177 | if (nbytes) { |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1178 | /* good enough to not time out |
| 1179 | */ |
Simon Glass | 09007c4 | 2014-04-10 20:01:31 -0600 | [diff] [blame] | 1180 | bootretry_reset_cmd_timeout(); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1181 | if (size == 4) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 1182 | *((u32 *)ptr) = i; |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1183 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1184 | else if (size == 8) |
| 1185 | *((u64 *)ptr) = i; |
| 1186 | #endif |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1187 | else if (size == 2) |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 1188 | *((u16 *)ptr) = i; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1189 | else |
York Sun | d8a405d | 2014-02-12 15:55:35 -0800 | [diff] [blame] | 1190 | *((u8 *)ptr) = i; |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1191 | if (incrflag) |
| 1192 | addr += size; |
| 1193 | } |
| 1194 | } |
| 1195 | } while (nbytes); |
Simon Glass | e6d0ca2 | 2013-02-24 17:33:15 +0000 | [diff] [blame] | 1196 | if (ptr) |
| 1197 | unmap_sysmem(ptr); |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1198 | |
| 1199 | mm_last_addr = addr; |
| 1200 | mm_last_size = size; |
| 1201 | return 0; |
| 1202 | } |
| 1203 | |
Mike Frysinger | 321ab9e | 2010-12-21 14:19:51 -0500 | [diff] [blame] | 1204 | #ifdef CONFIG_CMD_CRC32 |
| 1205 | |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 1206 | static int do_mem_crc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
wdenk | 3863585 | 2002-08-27 05:55:31 +0000 | [diff] [blame] | 1207 | { |
Simon Glass | 0bbd76f | 2013-02-24 20:30:22 +0000 | [diff] [blame] | 1208 | int flags = 0; |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1209 | int ac; |
Wolfgang Denk | 6262d021 | 2010-06-28 22:00:46 +0200 | [diff] [blame] | 1210 | char * const *av; |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1211 | |
Simon Glass | 0bbd76f | 2013-02-24 20:30:22 +0000 | [diff] [blame] | 1212 | if (argc < 3) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 1213 | return CMD_RET_USAGE; |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1214 | |
| 1215 | av = argv + 1; |
| 1216 | ac = argc - 1; |
Simon Glass | 0bbd76f | 2013-02-24 20:30:22 +0000 | [diff] [blame] | 1217 | #ifdef CONFIG_HASH_VERIFY |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1218 | if (strcmp(*av, "-v") == 0) { |
Simon Glass | 0bbd76f | 2013-02-24 20:30:22 +0000 | [diff] [blame] | 1219 | flags |= HASH_FLAG_VERIFY; |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1220 | av++; |
| 1221 | ac--; |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1222 | } |
Simon Glass | 0bbd76f | 2013-02-24 20:30:22 +0000 | [diff] [blame] | 1223 | #endif |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1224 | |
Simon Glass | 0bbd76f | 2013-02-24 20:30:22 +0000 | [diff] [blame] | 1225 | return hash_command("crc32", flags, cmdtp, flag, ac, av); |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1226 | } |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1227 | |
Robin Getz | 93d6cb0 | 2009-07-27 00:07:59 -0400 | [diff] [blame] | 1228 | #endif |
| 1229 | |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1230 | /**************************************************/ |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1231 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1232 | md, 3, 1, do_mem_md, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1233 | "memory display", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1234 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1235 | "[.b, .w, .l, .q] address [# of objects]" |
| 1236 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1237 | "[.b, .w, .l] address [# of objects]" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1238 | #endif |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1239 | ); |
| 1240 | |
| 1241 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1242 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1243 | mm, 2, 1, do_mem_mm, |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1244 | "memory modify (auto-incrementing address)", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1245 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1246 | "[.b, .w, .l, .q] address" |
| 1247 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1248 | "[.b, .w, .l] address" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1249 | #endif |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1250 | ); |
| 1251 | |
| 1252 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1253 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1254 | nm, 2, 1, do_mem_nm, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1255 | "memory modify (constant address)", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1256 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1257 | "[.b, .w, .l, .q] address" |
| 1258 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1259 | "[.b, .w, .l] address" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1260 | #endif |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1261 | ); |
| 1262 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1263 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1264 | mw, 4, 1, do_mem_mw, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1265 | "memory write (fill)", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1266 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1267 | "[.b, .w, .l, .q] address value [count]" |
| 1268 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1269 | "[.b, .w, .l] address value [count]" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1270 | #endif |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1271 | ); |
| 1272 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1273 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1274 | cp, 4, 1, do_mem_cp, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1275 | "memory copy", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1276 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1277 | "[.b, .w, .l, .q] source target count" |
| 1278 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1279 | "[.b, .w, .l] source target count" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1280 | #endif |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1281 | ); |
| 1282 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1283 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1284 | cmp, 4, 1, do_mem_cmp, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1285 | "memory compare", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1286 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1287 | "[.b, .w, .l, .q] addr1 addr2 count" |
| 1288 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1289 | "[.b, .w, .l] addr1 addr2 count" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1290 | #endif |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1291 | ); |
| 1292 | |
Mike Frysinger | 321ab9e | 2010-12-21 14:19:51 -0500 | [diff] [blame] | 1293 | #ifdef CONFIG_CMD_CRC32 |
| 1294 | |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1295 | #ifndef CONFIG_CRC32_VERIFY |
| 1296 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1297 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1298 | crc32, 4, 1, do_mem_crc, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1299 | "checksum calculation", |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1300 | "address count [addr]\n - compute CRC32 checksum [save at addr]" |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1301 | ); |
| 1302 | |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1303 | #else /* CONFIG_CRC32_VERIFY */ |
| 1304 | |
| 1305 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1306 | crc32, 5, 1, do_mem_crc, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1307 | "checksum calculation", |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1308 | "address count [addr]\n - compute CRC32 checksum [save at addr]\n" |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1309 | "-v address count crc\n - verify crc of memory area" |
wdenk | 6203e40 | 2004-04-18 10:13:26 +0000 | [diff] [blame] | 1310 | ); |
| 1311 | |
| 1312 | #endif /* CONFIG_CRC32_VERIFY */ |
| 1313 | |
Mike Frysinger | 321ab9e | 2010-12-21 14:19:51 -0500 | [diff] [blame] | 1314 | #endif |
| 1315 | |
Simon Glass | eacd14f | 2012-11-30 13:01:20 +0000 | [diff] [blame] | 1316 | #ifdef CONFIG_CMD_MEMINFO |
| 1317 | __weak void board_show_dram(ulong size) |
| 1318 | { |
| 1319 | puts("DRAM: "); |
| 1320 | print_size(size, "\n"); |
| 1321 | } |
| 1322 | |
| 1323 | static int do_mem_info(cmd_tbl_t *cmdtp, int flag, int argc, |
| 1324 | char * const argv[]) |
| 1325 | { |
| 1326 | board_show_dram(gd->ram_size); |
| 1327 | |
| 1328 | return 0; |
| 1329 | } |
| 1330 | #endif |
| 1331 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1332 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1333 | base, 2, 1, do_mem_base, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1334 | "print or set address offset", |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1335 | "\n - print address offset for memory commands\n" |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1336 | "base off\n - set address offset for memory commands to 'off'" |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1337 | ); |
| 1338 | |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1339 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1340 | loop, 3, 1, do_mem_loop, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1341 | "infinite loop on address range", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1342 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1343 | "[.b, .w, .l, .q] address number_of_objects" |
| 1344 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1345 | "[.b, .w, .l] address number_of_objects" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1346 | #endif |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1347 | ); |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 1348 | |
| 1349 | #ifdef CONFIG_LOOPW |
| 1350 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1351 | loopw, 4, 1, do_mem_loopw, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1352 | "infinite write loop on address range", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1353 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1354 | "[.b, .w, .l, .q] address number_of_objects data_to_write" |
| 1355 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1356 | "[.b, .w, .l] address number_of_objects data_to_write" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1357 | #endif |
wdenk | 6451936 | 2004-07-11 17:40:54 +0000 | [diff] [blame] | 1358 | ); |
| 1359 | #endif /* CONFIG_LOOPW */ |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1360 | |
Wolfgang Denk | 9d00928 | 2013-03-08 10:51:32 +0000 | [diff] [blame] | 1361 | #ifdef CONFIG_CMD_MEMTEST |
wdenk | f287a24 | 2003-07-01 21:06:45 +0000 | [diff] [blame] | 1362 | U_BOOT_CMD( |
Dirk Eibach | b265989 | 2008-12-16 14:51:56 +0100 | [diff] [blame] | 1363 | mtest, 5, 1, do_mem_mtest, |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1364 | "simple RAM read/write test", |
| 1365 | "[start [end [pattern [iterations]]]]" |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1366 | ); |
Wolfgang Denk | 9d00928 | 2013-03-08 10:51:32 +0000 | [diff] [blame] | 1367 | #endif /* CONFIG_CMD_MEMTEST */ |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 1368 | |
| 1369 | #ifdef CONFIG_MX_CYCLIC |
| 1370 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1371 | mdc, 4, 1, do_mem_mdc, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1372 | "memory display cyclic", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1373 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1374 | "[.b, .w, .l, .q] address count delay(ms)" |
| 1375 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1376 | "[.b, .w, .l] address count delay(ms)" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1377 | #endif |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 1378 | ); |
| 1379 | |
| 1380 | U_BOOT_CMD( |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 1381 | mwc, 4, 1, do_mem_mwc, |
Peter Tyser | dfb72b8 | 2009-01-27 18:03:12 -0600 | [diff] [blame] | 1382 | "memory write cyclic", |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1383 | #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA |
| 1384 | "[.b, .w, .l, .q] address value delay(ms)" |
| 1385 | #else |
Wolfgang Denk | c54781c | 2009-05-24 17:06:54 +0200 | [diff] [blame] | 1386 | "[.b, .w, .l] address value delay(ms)" |
York Sun | 6c48001 | 2014-02-26 17:03:19 -0800 | [diff] [blame] | 1387 | #endif |
stroese | fb5e0ac | 2004-12-16 17:42:39 +0000 | [diff] [blame] | 1388 | ); |
| 1389 | #endif /* CONFIG_MX_CYCLIC */ |
Simon Glass | eacd14f | 2012-11-30 13:01:20 +0000 | [diff] [blame] | 1390 | |
| 1391 | #ifdef CONFIG_CMD_MEMINFO |
| 1392 | U_BOOT_CMD( |
| 1393 | meminfo, 3, 1, do_mem_info, |
| 1394 | "display memory information", |
| 1395 | "" |
| 1396 | ); |
| 1397 | #endif |