blob: 5d8c9e6c061c31dcf7fb2f50374d02e5dd72ceb1 [file] [log] [blame]
wdenk38635852002-08-27 05:55:31 +00001/*
2 * (C) Copyright 2000
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02005 * SPDX-License-Identifier: GPL-2.0+
wdenk38635852002-08-27 05:55:31 +00006 */
7
8/*
9 * Memory Functions
10 *
11 * Copied from FADS ROM, Dan Malek (dmalek@jlc.net)
12 */
13
14#include <common.h>
Simon Glass0098e172014-04-10 20:01:30 -060015#include <bootretry.h>
Simon Glass18d66532014-04-10 20:01:25 -060016#include <cli.h>
wdenk38635852002-08-27 05:55:31 +000017#include <command.h>
wdenk2abbe072003-06-16 23:50:08 +000018#ifdef CONFIG_HAS_DATAFLASH
19#include <dataflash.h>
20#endif
Simon Glassd20a40d2013-02-24 20:30:22 +000021#include <hash.h>
Simon Glasse48f3742014-11-11 12:47:07 -070022#include <inttypes.h>
Joe Hershberger0eb25b62015-03-22 17:08:59 -050023#include <mapmem.h>
Sergei Poselenova6e6fc62008-04-09 16:09:41 +020024#include <watchdog.h>
Simon Glass0628ab82013-02-24 17:33:15 +000025#include <asm/io.h>
Simon Glass15a33e42012-11-30 13:01:20 +000026#include <linux/compiler.h>
27
28DECLARE_GLOBAL_DATA_PTR;
wdenk38635852002-08-27 05:55:31 +000029
Simon Glass8e169cc2013-02-24 17:33:29 +000030#ifndef CONFIG_SYS_MEMTEST_SCRATCH
31#define CONFIG_SYS_MEMTEST_SCRATCH 0
32#endif
33
Wolfgang Denk54841ab2010-06-28 22:00:46 +020034static int mod_mem(cmd_tbl_t *, int, int, int, char * const []);
wdenk38635852002-08-27 05:55:31 +000035
36/* Display values from last command.
37 * Memory modify remembered values are different from display memory.
38 */
Scott Wood581508b2015-03-19 09:43:12 -070039static ulong dp_last_addr, dp_last_size;
40static ulong dp_last_length = 0x40;
41static ulong mm_last_addr, mm_last_size;
wdenk38635852002-08-27 05:55:31 +000042
43static ulong base_address = 0;
44
45/* Memory Display
46 *
47 * Syntax:
York Sun4d1fd7f2014-02-26 17:03:19 -080048 * md{.b, .w, .l, .q} {addr} {len}
wdenk38635852002-08-27 05:55:31 +000049 */
50#define DISP_LINE_LEN 16
Kim Phillips088f1b12012-10-29 13:34:31 +000051static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +000052{
wdenk27b207f2003-07-24 23:38:38 +000053 ulong addr, length;
Grant Likelyc95c4282007-02-20 09:05:00 +010054#if defined(CONFIG_HAS_DATAFLASH)
55 ulong nbytes, linebytes;
56#endif
wdenk27b207f2003-07-24 23:38:38 +000057 int size;
wdenk38635852002-08-27 05:55:31 +000058 int rc = 0;
59
60 /* We use the last specified parameters, unless new ones are
61 * entered.
62 */
63 addr = dp_last_addr;
64 size = dp_last_size;
65 length = dp_last_length;
66
Wolfgang Denk47e26b12010-07-17 01:06:04 +020067 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +000068 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +000069
70 if ((flag & CMD_FLAG_REPEAT) == 0) {
71 /* New command specified. Check for a size specification.
72 * Defaults to long if no or incorrect specification.
73 */
wdenk27b207f2003-07-24 23:38:38 +000074 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
75 return 1;
wdenk38635852002-08-27 05:55:31 +000076
77 /* Address is specified since argc > 1
78 */
79 addr = simple_strtoul(argv[1], NULL, 16);
80 addr += base_address;
81
82 /* If another parameter, it is the length to display.
83 * Length is the number of objects, not number of bytes.
84 */
85 if (argc > 2)
86 length = simple_strtoul(argv[2], NULL, 16);
87 }
88
Grant Likelyc95c4282007-02-20 09:05:00 +010089#if defined(CONFIG_HAS_DATAFLASH)
wdenk38635852002-08-27 05:55:31 +000090 /* Print the lines.
91 *
92 * We buffer all read data, so we can make sure data is read only
93 * once, and all accesses are with the specified bus width.
94 */
95 nbytes = length * size;
96 do {
97 char linebuf[DISP_LINE_LEN];
Grant Likelyc95c4282007-02-20 09:05:00 +010098 void* p;
wdenk38635852002-08-27 05:55:31 +000099 linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;
wdenk2abbe072003-06-16 23:50:08 +0000100
Grant Likelyc95c4282007-02-20 09:05:00 +0100101 rc = read_dataflash(addr, (linebytes/size)*size, linebuf);
102 p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr;
103 print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size);
wdenk8bde7f72003-06-27 21:31:46 +0000104
wdenk38635852002-08-27 05:55:31 +0000105 nbytes -= linebytes;
Grant Likelyc95c4282007-02-20 09:05:00 +0100106 addr += linebytes;
wdenk38635852002-08-27 05:55:31 +0000107 if (ctrlc()) {
108 rc = 1;
109 break;
110 }
111 } while (nbytes > 0);
Grant Likelyc95c4282007-02-20 09:05:00 +0100112#else
Mike Frysinger4c727c72008-02-04 19:26:56 -0500113
114# if defined(CONFIG_BLACKFIN)
115 /* See if we're trying to display L1 inst */
116 if (addr_bfin_on_chip_mem(addr)) {
117 char linebuf[DISP_LINE_LEN];
118 ulong linebytes, nbytes = length * size;
119 do {
120 linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
121 memcpy(linebuf, (void *)addr, linebytes);
122 print_buffer(addr, linebuf, size, linebytes/size, DISP_LINE_LEN/size);
123
124 nbytes -= linebytes;
125 addr += linebytes;
126 if (ctrlc()) {
127 rc = 1;
128 break;
129 }
130 } while (nbytes > 0);
131 } else
132# endif
133
134 {
Simon Glass0628ab82013-02-24 17:33:15 +0000135 ulong bytes = size * length;
136 const void *buf = map_sysmem(addr, bytes);
137
Mike Frysinger4c727c72008-02-04 19:26:56 -0500138 /* Print the lines. */
Simon Glass0628ab82013-02-24 17:33:15 +0000139 print_buffer(addr, buf, size, length, DISP_LINE_LEN / size);
140 addr += bytes;
141 unmap_sysmem(buf);
Mike Frysinger4c727c72008-02-04 19:26:56 -0500142 }
Grant Likelyc95c4282007-02-20 09:05:00 +0100143#endif
wdenk38635852002-08-27 05:55:31 +0000144
145 dp_last_addr = addr;
146 dp_last_length = length;
147 dp_last_size = size;
148 return (rc);
149}
150
Kim Phillips088f1b12012-10-29 13:34:31 +0000151static int do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000152{
153 return mod_mem (cmdtp, 1, flag, argc, argv);
154}
Kim Phillips088f1b12012-10-29 13:34:31 +0000155static int do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000156{
157 return mod_mem (cmdtp, 0, flag, argc, argv);
158}
159
Kim Phillips088f1b12012-10-29 13:34:31 +0000160static int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000161{
York Sun4d1fd7f2014-02-26 17:03:19 -0800162#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
163 u64 writeval;
164#else
165 ulong writeval;
166#endif
167 ulong addr, count;
wdenk27b207f2003-07-24 23:38:38 +0000168 int size;
Simon Glasscc5e1962015-03-05 12:25:18 -0700169 void *buf, *start;
Simon Glass0628ab82013-02-24 17:33:15 +0000170 ulong bytes;
wdenk38635852002-08-27 05:55:31 +0000171
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200172 if ((argc < 3) || (argc > 4))
Simon Glass4c12eeb2011-12-10 08:44:01 +0000173 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000174
175 /* Check for size specification.
176 */
wdenk27b207f2003-07-24 23:38:38 +0000177 if ((size = cmd_get_data_size(argv[0], 4)) < 1)
178 return 1;
wdenk38635852002-08-27 05:55:31 +0000179
180 /* Address is specified since argc > 1
181 */
182 addr = simple_strtoul(argv[1], NULL, 16);
183 addr += base_address;
184
185 /* Get the value to write.
186 */
York Sun4d1fd7f2014-02-26 17:03:19 -0800187#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
188 writeval = simple_strtoull(argv[2], NULL, 16);
189#else
wdenk38635852002-08-27 05:55:31 +0000190 writeval = simple_strtoul(argv[2], NULL, 16);
York Sun4d1fd7f2014-02-26 17:03:19 -0800191#endif
wdenk38635852002-08-27 05:55:31 +0000192
193 /* Count ? */
194 if (argc == 4) {
195 count = simple_strtoul(argv[3], NULL, 16);
196 } else {
197 count = 1;
198 }
199
Simon Glass0628ab82013-02-24 17:33:15 +0000200 bytes = size * count;
Simon Glasscc5e1962015-03-05 12:25:18 -0700201 start = map_sysmem(addr, bytes);
202 buf = start;
wdenk38635852002-08-27 05:55:31 +0000203 while (count-- > 0) {
204 if (size == 4)
York Sun76698b42014-02-12 15:55:35 -0800205 *((u32 *)buf) = (u32)writeval;
York Sun4d1fd7f2014-02-26 17:03:19 -0800206#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
207 else if (size == 8)
208 *((u64 *)buf) = (u64)writeval;
209#endif
wdenk38635852002-08-27 05:55:31 +0000210 else if (size == 2)
York Sun76698b42014-02-12 15:55:35 -0800211 *((u16 *)buf) = (u16)writeval;
wdenk38635852002-08-27 05:55:31 +0000212 else
York Sun76698b42014-02-12 15:55:35 -0800213 *((u8 *)buf) = (u8)writeval;
Simon Glass0628ab82013-02-24 17:33:15 +0000214 buf += size;
wdenk38635852002-08-27 05:55:31 +0000215 }
Simon Glasscc5e1962015-03-05 12:25:18 -0700216 unmap_sysmem(start);
wdenk38635852002-08-27 05:55:31 +0000217 return 0;
218}
219
stroese4aaf29b2004-12-16 17:42:39 +0000220#ifdef CONFIG_MX_CYCLIC
Masahiro Yamada5a8608e2014-09-04 00:38:26 +0900221static int do_mem_mdc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
stroese4aaf29b2004-12-16 17:42:39 +0000222{
223 int i;
224 ulong count;
225
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200226 if (argc < 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000227 return CMD_RET_USAGE;
stroese4aaf29b2004-12-16 17:42:39 +0000228
229 count = simple_strtoul(argv[3], NULL, 10);
230
231 for (;;) {
232 do_mem_md (NULL, 0, 3, argv);
233
234 /* delay for <count> ms... */
235 for (i=0; i<count; i++)
236 udelay (1000);
237
238 /* check for ctrl-c to abort... */
239 if (ctrlc()) {
240 puts("Abort\n");
241 return 0;
242 }
243 }
244
245 return 0;
246}
247
Masahiro Yamada5a8608e2014-09-04 00:38:26 +0900248static int do_mem_mwc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
stroese4aaf29b2004-12-16 17:42:39 +0000249{
250 int i;
251 ulong count;
252
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200253 if (argc < 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000254 return CMD_RET_USAGE;
stroese4aaf29b2004-12-16 17:42:39 +0000255
256 count = simple_strtoul(argv[3], NULL, 10);
257
258 for (;;) {
259 do_mem_mw (NULL, 0, 3, argv);
260
261 /* delay for <count> ms... */
262 for (i=0; i<count; i++)
263 udelay (1000);
264
265 /* check for ctrl-c to abort... */
266 if (ctrlc()) {
267 puts("Abort\n");
268 return 0;
269 }
270 }
271
272 return 0;
273}
274#endif /* CONFIG_MX_CYCLIC */
275
Kim Phillips088f1b12012-10-29 13:34:31 +0000276static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000277{
Simon Glass0628ab82013-02-24 17:33:15 +0000278 ulong addr1, addr2, count, ngood, bytes;
wdenk27b207f2003-07-24 23:38:38 +0000279 int size;
wdenk38635852002-08-27 05:55:31 +0000280 int rcode = 0;
Mike Frysinger054ea172012-01-20 09:07:21 +0000281 const char *type;
Simon Glass0628ab82013-02-24 17:33:15 +0000282 const void *buf1, *buf2, *base;
York Sun4d1fd7f2014-02-26 17:03:19 -0800283#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
284 u64 word1, word2;
285#else
286 ulong word1, word2;
287#endif
wdenk38635852002-08-27 05:55:31 +0000288
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200289 if (argc != 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000290 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000291
292 /* Check for size specification.
293 */
wdenk27b207f2003-07-24 23:38:38 +0000294 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
295 return 1;
York Sun4d1fd7f2014-02-26 17:03:19 -0800296 type = size == 8 ? "double word" :
297 size == 4 ? "word" :
298 size == 2 ? "halfword" : "byte";
wdenk38635852002-08-27 05:55:31 +0000299
300 addr1 = simple_strtoul(argv[1], NULL, 16);
301 addr1 += base_address;
302
303 addr2 = simple_strtoul(argv[2], NULL, 16);
304 addr2 += base_address;
305
306 count = simple_strtoul(argv[3], NULL, 16);
307
wdenk2abbe072003-06-16 23:50:08 +0000308#ifdef CONFIG_HAS_DATAFLASH
309 if (addr_dataflash(addr1) | addr_dataflash(addr2)){
wdenk4b9206e2004-03-23 22:14:11 +0000310 puts ("Comparison with DataFlash space not supported.\n\r");
wdenk2abbe072003-06-16 23:50:08 +0000311 return 0;
312 }
313#endif
314
Mike Frysinger4c727c72008-02-04 19:26:56 -0500315#ifdef CONFIG_BLACKFIN
316 if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) {
317 puts ("Comparison with L1 instruction memory not supported.\n\r");
318 return 0;
319 }
320#endif
321
Simon Glass0628ab82013-02-24 17:33:15 +0000322 bytes = size * count;
323 base = buf1 = map_sysmem(addr1, bytes);
324 buf2 = map_sysmem(addr2, bytes);
Mike Frysingerfeb12a12012-01-20 09:07:22 +0000325 for (ngood = 0; ngood < count; ++ngood) {
wdenk38635852002-08-27 05:55:31 +0000326 if (size == 4) {
York Sun76698b42014-02-12 15:55:35 -0800327 word1 = *(u32 *)buf1;
328 word2 = *(u32 *)buf2;
York Sun4d1fd7f2014-02-26 17:03:19 -0800329#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
330 } else if (size == 8) {
331 word1 = *(u64 *)buf1;
332 word2 = *(u64 *)buf2;
333#endif
Mike Frysinger054ea172012-01-20 09:07:21 +0000334 } else if (size == 2) {
York Sun76698b42014-02-12 15:55:35 -0800335 word1 = *(u16 *)buf1;
336 word2 = *(u16 *)buf2;
Mike Frysinger054ea172012-01-20 09:07:21 +0000337 } else {
York Sun76698b42014-02-12 15:55:35 -0800338 word1 = *(u8 *)buf1;
339 word2 = *(u8 *)buf2;
wdenk38635852002-08-27 05:55:31 +0000340 }
Mike Frysinger054ea172012-01-20 09:07:21 +0000341 if (word1 != word2) {
Simon Glass0628ab82013-02-24 17:33:15 +0000342 ulong offset = buf1 - base;
York Sun4d1fd7f2014-02-26 17:03:19 -0800343#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
Simon Glasse48f3742014-11-11 12:47:07 -0700344 printf("%s at 0x%p (%#0*"PRIx64") != %s at 0x%p (%#0*"
345 PRIx64 ")\n",
York Sun4d1fd7f2014-02-26 17:03:19 -0800346 type, (void *)(addr1 + offset), size, word1,
347 type, (void *)(addr2 + offset), size, word2);
348#else
Mike Frysinger054ea172012-01-20 09:07:21 +0000349 printf("%s at 0x%08lx (%#0*lx) != %s at 0x%08lx (%#0*lx)\n",
Simon Glass0628ab82013-02-24 17:33:15 +0000350 type, (ulong)(addr1 + offset), size, word1,
351 type, (ulong)(addr2 + offset), size, word2);
York Sun4d1fd7f2014-02-26 17:03:19 -0800352#endif
Mike Frysinger054ea172012-01-20 09:07:21 +0000353 rcode = 1;
354 break;
wdenk38635852002-08-27 05:55:31 +0000355 }
Mike Frysinger054ea172012-01-20 09:07:21 +0000356
Simon Glass0628ab82013-02-24 17:33:15 +0000357 buf1 += size;
358 buf2 += size;
Stefan Roeseeaadb442010-09-13 11:10:34 +0200359
360 /* reset watchdog from time to time */
Mike Frysingerfeb12a12012-01-20 09:07:22 +0000361 if ((ngood % (64 << 10)) == 0)
Stefan Roeseeaadb442010-09-13 11:10:34 +0200362 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000363 }
Simon Glass0628ab82013-02-24 17:33:15 +0000364 unmap_sysmem(buf1);
365 unmap_sysmem(buf2);
wdenk38635852002-08-27 05:55:31 +0000366
Mike Frysinger054ea172012-01-20 09:07:21 +0000367 printf("Total of %ld %s(s) were the same\n", ngood, type);
wdenk38635852002-08-27 05:55:31 +0000368 return rcode;
369}
370
Kim Phillips088f1b12012-10-29 13:34:31 +0000371static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000372{
Simon Glass0628ab82013-02-24 17:33:15 +0000373 ulong addr, dest, count, bytes;
wdenk27b207f2003-07-24 23:38:38 +0000374 int size;
Simon Glass0628ab82013-02-24 17:33:15 +0000375 const void *src;
376 void *buf;
wdenk38635852002-08-27 05:55:31 +0000377
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200378 if (argc != 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000379 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000380
381 /* Check for size specification.
382 */
wdenk27b207f2003-07-24 23:38:38 +0000383 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
384 return 1;
wdenk38635852002-08-27 05:55:31 +0000385
386 addr = simple_strtoul(argv[1], NULL, 16);
387 addr += base_address;
388
389 dest = simple_strtoul(argv[2], NULL, 16);
390 dest += base_address;
391
392 count = simple_strtoul(argv[3], NULL, 16);
393
394 if (count == 0) {
395 puts ("Zero length ???\n");
396 return 1;
397 }
398
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200399#ifndef CONFIG_SYS_NO_FLASH
wdenk38635852002-08-27 05:55:31 +0000400 /* check if we are copying to Flash */
wdenk2abbe072003-06-16 23:50:08 +0000401 if ( (addr2info(dest) != NULL)
402#ifdef CONFIG_HAS_DATAFLASH
Kim B. Heino84d0c2f2008-03-03 10:39:13 +0200403 && (!addr_dataflash(dest))
wdenk2abbe072003-06-16 23:50:08 +0000404#endif
405 ) {
wdenk38635852002-08-27 05:55:31 +0000406 int rc;
407
wdenk4b9206e2004-03-23 22:14:11 +0000408 puts ("Copy to Flash... ");
wdenk38635852002-08-27 05:55:31 +0000409
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200410 rc = flash_write ((char *)addr, dest, count*size);
wdenk38635852002-08-27 05:55:31 +0000411 if (rc != 0) {
412 flash_perror (rc);
413 return (1);
414 }
415 puts ("done\n");
416 return 0;
417 }
418#endif
419
wdenk2abbe072003-06-16 23:50:08 +0000420#ifdef CONFIG_HAS_DATAFLASH
421 /* Check if we are copying from RAM or Flash to DataFlash */
422 if (addr_dataflash(dest) && !addr_dataflash(addr)){
423 int rc;
424
wdenk4b9206e2004-03-23 22:14:11 +0000425 puts ("Copy to DataFlash... ");
wdenk2abbe072003-06-16 23:50:08 +0000426
427 rc = write_dataflash (dest, addr, count*size);
428
429 if (rc != 1) {
430 dataflash_perror (rc);
431 return (1);
432 }
433 puts ("done\n");
434 return 0;
435 }
wdenk8bde7f72003-06-27 21:31:46 +0000436
wdenk2abbe072003-06-16 23:50:08 +0000437 /* Check if we are copying from DataFlash to RAM */
Stelian Pop880cc432008-03-26 22:52:35 +0100438 if (addr_dataflash(addr) && !addr_dataflash(dest)
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200439#ifndef CONFIG_SYS_NO_FLASH
Stelian Pop880cc432008-03-26 22:52:35 +0100440 && (addr2info(dest) == NULL)
441#endif
442 ){
wdenk5779d8d2003-12-06 23:55:10 +0000443 int rc;
444 rc = read_dataflash(addr, count * size, (char *) dest);
445 if (rc != 1) {
wdenkd4ca31c2004-01-02 14:00:00 +0000446 dataflash_perror (rc);
447 return (1);
448 }
wdenk2abbe072003-06-16 23:50:08 +0000449 return 0;
450 }
451
452 if (addr_dataflash(addr) && addr_dataflash(dest)){
wdenk4b9206e2004-03-23 22:14:11 +0000453 puts ("Unsupported combination of source/destination.\n\r");
wdenk2abbe072003-06-16 23:50:08 +0000454 return 1;
455 }
456#endif
457
Mike Frysinger4c727c72008-02-04 19:26:56 -0500458#ifdef CONFIG_BLACKFIN
459 /* See if we're copying to/from L1 inst */
460 if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) {
461 memcpy((void *)dest, (void *)addr, count * size);
462 return 0;
463 }
464#endif
465
Simon Glass0628ab82013-02-24 17:33:15 +0000466 bytes = size * count;
Masahiro Yamada53237af2013-05-20 21:08:08 +0000467 buf = map_sysmem(dest, bytes);
Simon Glass0628ab82013-02-24 17:33:15 +0000468 src = map_sysmem(addr, bytes);
wdenk38635852002-08-27 05:55:31 +0000469 while (count-- > 0) {
470 if (size == 4)
York Sun76698b42014-02-12 15:55:35 -0800471 *((u32 *)buf) = *((u32 *)src);
York Sun4d1fd7f2014-02-26 17:03:19 -0800472#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
473 else if (size == 8)
474 *((u64 *)buf) = *((u64 *)src);
475#endif
wdenk38635852002-08-27 05:55:31 +0000476 else if (size == 2)
York Sun76698b42014-02-12 15:55:35 -0800477 *((u16 *)buf) = *((u16 *)src);
wdenk38635852002-08-27 05:55:31 +0000478 else
York Sun76698b42014-02-12 15:55:35 -0800479 *((u8 *)buf) = *((u8 *)src);
Simon Glass0628ab82013-02-24 17:33:15 +0000480 src += size;
481 buf += size;
Stefan Roeseeaadb442010-09-13 11:10:34 +0200482
483 /* reset watchdog from time to time */
484 if ((count % (64 << 10)) == 0)
485 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000486 }
Masahiro Yamadaa3a47492014-10-23 17:46:24 +0900487 unmap_sysmem(buf);
488 unmap_sysmem(src);
489
wdenk38635852002-08-27 05:55:31 +0000490 return 0;
491}
492
Kim Phillips088f1b12012-10-29 13:34:31 +0000493static int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
494 char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000495{
496 if (argc > 1) {
497 /* Set new base address.
498 */
499 base_address = simple_strtoul(argv[1], NULL, 16);
500 }
501 /* Print the current base address.
502 */
503 printf("Base Address: 0x%08lx\n", base_address);
504 return 0;
505}
506
Kim Phillips088f1b12012-10-29 13:34:31 +0000507static int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
508 char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000509{
Simon Glass0628ab82013-02-24 17:33:15 +0000510 ulong addr, length, i, bytes;
wdenk27b207f2003-07-24 23:38:38 +0000511 int size;
York Sun4d1fd7f2014-02-26 17:03:19 -0800512#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
513 volatile u64 *llp;
514#endif
York Sun76698b42014-02-12 15:55:35 -0800515 volatile u32 *longp;
516 volatile u16 *shortp;
517 volatile u8 *cp;
Simon Glass0628ab82013-02-24 17:33:15 +0000518 const void *buf;
wdenk38635852002-08-27 05:55:31 +0000519
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200520 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000521 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000522
Robert P. J. Day85de63e2013-02-03 02:29:54 +0000523 /*
524 * Check for a size specification.
wdenk38635852002-08-27 05:55:31 +0000525 * Defaults to long if no or incorrect specification.
526 */
wdenk27b207f2003-07-24 23:38:38 +0000527 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
528 return 1;
wdenk38635852002-08-27 05:55:31 +0000529
530 /* Address is always specified.
531 */
532 addr = simple_strtoul(argv[1], NULL, 16);
533
534 /* Length is the number of objects, not number of bytes.
535 */
536 length = simple_strtoul(argv[2], NULL, 16);
537
Simon Glass0628ab82013-02-24 17:33:15 +0000538 bytes = size * length;
539 buf = map_sysmem(addr, bytes);
540
wdenk38635852002-08-27 05:55:31 +0000541 /* We want to optimize the loops to run as fast as possible.
542 * If we have only one object, just run infinite loops.
543 */
544 if (length == 1) {
York Sun4d1fd7f2014-02-26 17:03:19 -0800545#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
546 if (size == 8) {
547 llp = (u64 *)buf;
548 for (;;)
549 i = *llp;
550 }
551#endif
wdenk38635852002-08-27 05:55:31 +0000552 if (size == 4) {
York Sun76698b42014-02-12 15:55:35 -0800553 longp = (u32 *)buf;
wdenk38635852002-08-27 05:55:31 +0000554 for (;;)
555 i = *longp;
556 }
557 if (size == 2) {
York Sun76698b42014-02-12 15:55:35 -0800558 shortp = (u16 *)buf;
wdenk38635852002-08-27 05:55:31 +0000559 for (;;)
560 i = *shortp;
561 }
York Sun76698b42014-02-12 15:55:35 -0800562 cp = (u8 *)buf;
wdenk38635852002-08-27 05:55:31 +0000563 for (;;)
564 i = *cp;
565 }
566
York Sun4d1fd7f2014-02-26 17:03:19 -0800567#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
568 if (size == 8) {
569 for (;;) {
570 llp = (u64 *)buf;
571 i = length;
572 while (i-- > 0)
573 *llp++;
574 }
575 }
576#endif
wdenk38635852002-08-27 05:55:31 +0000577 if (size == 4) {
578 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800579 longp = (u32 *)buf;
wdenk38635852002-08-27 05:55:31 +0000580 i = length;
581 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200582 *longp++;
wdenk38635852002-08-27 05:55:31 +0000583 }
584 }
585 if (size == 2) {
586 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800587 shortp = (u16 *)buf;
wdenk38635852002-08-27 05:55:31 +0000588 i = length;
589 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200590 *shortp++;
wdenk38635852002-08-27 05:55:31 +0000591 }
592 }
593 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800594 cp = (u8 *)buf;
wdenk38635852002-08-27 05:55:31 +0000595 i = length;
596 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200597 *cp++;
wdenk38635852002-08-27 05:55:31 +0000598 }
Simon Glass0628ab82013-02-24 17:33:15 +0000599 unmap_sysmem(buf);
Simon Glass92765f422013-06-11 11:14:35 -0700600
601 return 0;
wdenk38635852002-08-27 05:55:31 +0000602}
603
wdenk56523f12004-07-11 17:40:54 +0000604#ifdef CONFIG_LOOPW
Masahiro Yamada5a8608e2014-09-04 00:38:26 +0900605static int do_mem_loopw(cmd_tbl_t *cmdtp, int flag, int argc,
606 char * const argv[])
wdenk56523f12004-07-11 17:40:54 +0000607{
York Sun4d1fd7f2014-02-26 17:03:19 -0800608 ulong addr, length, i, bytes;
wdenk56523f12004-07-11 17:40:54 +0000609 int size;
York Sun4d1fd7f2014-02-26 17:03:19 -0800610#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
611 volatile u64 *llp;
612 u64 data;
613#else
614 ulong data;
615#endif
York Sun76698b42014-02-12 15:55:35 -0800616 volatile u32 *longp;
617 volatile u16 *shortp;
618 volatile u8 *cp;
Simon Glass0628ab82013-02-24 17:33:15 +0000619 void *buf;
wdenk81050922004-07-11 20:04:51 +0000620
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200621 if (argc < 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000622 return CMD_RET_USAGE;
wdenk56523f12004-07-11 17:40:54 +0000623
Robert P. J. Day85de63e2013-02-03 02:29:54 +0000624 /*
625 * Check for a size specification.
wdenk56523f12004-07-11 17:40:54 +0000626 * Defaults to long if no or incorrect specification.
627 */
628 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
629 return 1;
630
631 /* Address is always specified.
632 */
633 addr = simple_strtoul(argv[1], NULL, 16);
634
635 /* Length is the number of objects, not number of bytes.
636 */
637 length = simple_strtoul(argv[2], NULL, 16);
638
639 /* data to write */
York Sun4d1fd7f2014-02-26 17:03:19 -0800640#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
641 data = simple_strtoull(argv[3], NULL, 16);
642#else
wdenk56523f12004-07-11 17:40:54 +0000643 data = simple_strtoul(argv[3], NULL, 16);
York Sun4d1fd7f2014-02-26 17:03:19 -0800644#endif
wdenk81050922004-07-11 20:04:51 +0000645
Simon Glass0628ab82013-02-24 17:33:15 +0000646 bytes = size * length;
647 buf = map_sysmem(addr, bytes);
648
wdenk56523f12004-07-11 17:40:54 +0000649 /* We want to optimize the loops to run as fast as possible.
650 * If we have only one object, just run infinite loops.
651 */
652 if (length == 1) {
York Sun4d1fd7f2014-02-26 17:03:19 -0800653#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
654 if (size == 8) {
655 llp = (u64 *)buf;
656 for (;;)
657 *llp = data;
658 }
659#endif
wdenk56523f12004-07-11 17:40:54 +0000660 if (size == 4) {
York Sun76698b42014-02-12 15:55:35 -0800661 longp = (u32 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000662 for (;;)
663 *longp = data;
York Sun4d1fd7f2014-02-26 17:03:19 -0800664 }
wdenk56523f12004-07-11 17:40:54 +0000665 if (size == 2) {
York Sun76698b42014-02-12 15:55:35 -0800666 shortp = (u16 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000667 for (;;)
668 *shortp = data;
669 }
York Sun76698b42014-02-12 15:55:35 -0800670 cp = (u8 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000671 for (;;)
672 *cp = data;
673 }
674
York Sun4d1fd7f2014-02-26 17:03:19 -0800675#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
676 if (size == 8) {
677 for (;;) {
678 llp = (u64 *)buf;
679 i = length;
680 while (i-- > 0)
681 *llp++ = data;
682 }
683 }
684#endif
wdenk56523f12004-07-11 17:40:54 +0000685 if (size == 4) {
686 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800687 longp = (u32 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000688 i = length;
689 while (i-- > 0)
690 *longp++ = data;
691 }
692 }
693 if (size == 2) {
694 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800695 shortp = (u16 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000696 i = length;
697 while (i-- > 0)
698 *shortp++ = data;
699 }
700 }
701 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800702 cp = (u8 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000703 i = length;
704 while (i-- > 0)
705 *cp++ = data;
706 }
707}
708#endif /* CONFIG_LOOPW */
709
Tom Rini68149e92013-03-12 10:07:19 -0400710#ifdef CONFIG_CMD_MEMTEST
Simon Glass5512d5b2013-02-28 17:47:14 +0000711static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
712 vu_long *dummy)
wdenk38635852002-08-27 05:55:31 +0000713{
Simon Glassc9638f52013-02-24 17:33:16 +0000714 vu_long *addr;
Simon Glassc9638f52013-02-24 17:33:16 +0000715 ulong errs = 0;
716 ulong val, readback;
717 int j;
Simon Glassc9638f52013-02-24 17:33:16 +0000718 vu_long offset;
719 vu_long test_offset;
720 vu_long pattern;
721 vu_long temp;
722 vu_long anti_pattern;
723 vu_long num_words;
wdenk38635852002-08-27 05:55:31 +0000724 static const ulong bitpattern[] = {
725 0x00000001, /* single bit */
726 0x00000003, /* two adjacent bits */
727 0x00000007, /* three adjacent bits */
728 0x0000000F, /* four adjacent bits */
729 0x00000005, /* two non-adjacent bits */
730 0x00000015, /* three non-adjacent bits */
731 0x00000055, /* four non-adjacent bits */
732 0xaaaaaaaa, /* alternating 1/0 */
733 };
wdenk38635852002-08-27 05:55:31 +0000734
Simon Glass5512d5b2013-02-28 17:47:14 +0000735 num_words = (end_addr - start_addr) / sizeof(vu_long);
Simon Glass8c86bbe2013-02-24 17:33:20 +0000736
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000737 /*
738 * Data line test: write a pattern to the first
739 * location, write the 1's complement to a 'parking'
740 * address (changes the state of the data bus so a
741 * floating bus doesn't give a false OK), and then
742 * read the value back. Note that we read it back
743 * into a variable because the next time we read it,
744 * it might be right (been there, tough to explain to
745 * the quality guys why it prints a failure when the
746 * "is" and "should be" are obviously the same in the
747 * error message).
748 *
749 * Rather than exhaustively testing, we test some
750 * patterns by shifting '1' bits through a field of
751 * '0's and '0' bits through a field of '1's (i.e.
752 * pattern and ~pattern).
753 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000754 addr = buf;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000755 for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) {
756 val = bitpattern[j];
757 for (; val != 0; val <<= 1) {
Simon Glass5512d5b2013-02-28 17:47:14 +0000758 *addr = val;
Simon Glassc9638f52013-02-24 17:33:16 +0000759 *dummy = ~val; /* clear the test data off the bus */
wdenk38635852002-08-27 05:55:31 +0000760 readback = *addr;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000761 if (readback != val) {
Simon Glassc9638f52013-02-24 17:33:16 +0000762 printf("FAILURE (data line): "
763 "expected %08lx, actual %08lx\n",
764 val, readback);
765 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000766 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000767 return -1;
wdenk38635852002-08-27 05:55:31 +0000768 }
769 *addr = ~val;
770 *dummy = val;
771 readback = *addr;
Simon Glassc9638f52013-02-24 17:33:16 +0000772 if (readback != ~val) {
773 printf("FAILURE (data line): "
774 "Is %08lx, should be %08lx\n",
775 readback, ~val);
776 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000777 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000778 return -1;
wdenk38635852002-08-27 05:55:31 +0000779 }
wdenk38635852002-08-27 05:55:31 +0000780 }
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000781 }
wdenk38635852002-08-27 05:55:31 +0000782
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000783 /*
784 * Based on code whose Original Author and Copyright
785 * information follows: Copyright (c) 1998 by Michael
786 * Barr. This software is placed into the public
787 * domain and may be used for any purpose. However,
788 * this notice must not be changed or removed and no
789 * warranty is either expressed or implied by its
790 * publication or distribution.
791 */
wdenk38635852002-08-27 05:55:31 +0000792
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000793 /*
794 * Address line test
wdenk38635852002-08-27 05:55:31 +0000795
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000796 * Description: Test the address bus wiring in a
797 * memory region by performing a walking
798 * 1's test on the relevant bits of the
799 * address and checking for aliasing.
800 * This test will find single-bit
801 * address failures such as stuck-high,
802 * stuck-low, and shorted pins. The base
803 * address and size of the region are
804 * selected by the caller.
wdenk38635852002-08-27 05:55:31 +0000805
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000806 * Notes: For best results, the selected base
807 * address should have enough LSB 0's to
808 * guarantee single address bit changes.
809 * For example, to test a 64-Kbyte
810 * region, select a base address on a
811 * 64-Kbyte boundary. Also, select the
812 * region size as a power-of-two if at
813 * all possible.
814 *
815 * Returns: 0 if the test succeeds, 1 if the test fails.
816 */
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000817 pattern = (vu_long) 0xaaaaaaaa;
818 anti_pattern = (vu_long) 0x55555555;
wdenk38635852002-08-27 05:55:31 +0000819
Simon Glass5512d5b2013-02-28 17:47:14 +0000820 debug("%s:%d: length = 0x%.8lx\n", __func__, __LINE__, num_words);
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000821 /*
822 * Write the default pattern at each of the
823 * power-of-two offsets.
824 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000825 for (offset = 1; offset < num_words; offset <<= 1)
826 addr[offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000827
828 /*
829 * Check for address bits stuck high.
830 */
831 test_offset = 0;
Simon Glass5512d5b2013-02-28 17:47:14 +0000832 addr[test_offset] = anti_pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000833
Simon Glass5512d5b2013-02-28 17:47:14 +0000834 for (offset = 1; offset < num_words; offset <<= 1) {
835 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000836 if (temp != pattern) {
Simon Glassc9638f52013-02-24 17:33:16 +0000837 printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
wdenk38635852002-08-27 05:55:31 +0000838 " expected 0x%.8lx, actual 0x%.8lx\n",
David Feng102c0512014-02-12 16:10:08 +0800839 start_addr + offset*sizeof(vu_long),
840 pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400841 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000842 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000843 return -1;
wdenk38635852002-08-27 05:55:31 +0000844 }
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000845 }
Simon Glass5512d5b2013-02-28 17:47:14 +0000846 addr[test_offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000847 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000848
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000849 /*
850 * Check for addr bits stuck low or shorted.
851 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000852 for (test_offset = 1; test_offset < num_words; test_offset <<= 1) {
853 addr[test_offset] = anti_pattern;
wdenk38635852002-08-27 05:55:31 +0000854
Simon Glass5512d5b2013-02-28 17:47:14 +0000855 for (offset = 1; offset < num_words; offset <<= 1) {
856 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000857 if ((temp != pattern) && (offset != test_offset)) {
858 printf("\nFAILURE: Address bit stuck low or"
859 " shorted @ 0x%.8lx: expected 0x%.8lx,"
860 " actual 0x%.8lx\n",
David Feng102c0512014-02-12 16:10:08 +0800861 start_addr + offset*sizeof(vu_long),
862 pattern, temp);
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000863 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000864 if (ctrlc())
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000865 return -1;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000866 }
wdenk38635852002-08-27 05:55:31 +0000867 }
Simon Glass5512d5b2013-02-28 17:47:14 +0000868 addr[test_offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000869 }
wdenk38635852002-08-27 05:55:31 +0000870
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000871 /*
872 * Description: Test the integrity of a physical
873 * memory device by performing an
874 * increment/decrement test over the
875 * entire region. In the process every
876 * storage bit in the device is tested
877 * as a zero and a one. The base address
878 * and the size of the region are
879 * selected by the caller.
880 *
881 * Returns: 0 if the test succeeds, 1 if the test fails.
882 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000883 num_words++;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000884
885 /*
886 * Fill memory with a known pattern.
887 */
888 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
889 WATCHDOG_RESET();
Simon Glass5512d5b2013-02-28 17:47:14 +0000890 addr[offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000891 }
892
893 /*
894 * Check each location and invert it for the second pass.
895 */
896 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
897 WATCHDOG_RESET();
Simon Glass5512d5b2013-02-28 17:47:14 +0000898 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000899 if (temp != pattern) {
Simon Glassc9638f52013-02-24 17:33:16 +0000900 printf("\nFAILURE (read/write) @ 0x%.8lx:"
wdenk38635852002-08-27 05:55:31 +0000901 " expected 0x%.8lx, actual 0x%.8lx)\n",
David Feng102c0512014-02-12 16:10:08 +0800902 start_addr + offset*sizeof(vu_long),
903 pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400904 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000905 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000906 return -1;
wdenk38635852002-08-27 05:55:31 +0000907 }
908
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000909 anti_pattern = ~pattern;
Simon Glass5512d5b2013-02-28 17:47:14 +0000910 addr[offset] = anti_pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000911 }
912
913 /*
914 * Check each location for the inverted pattern and zero it.
915 */
916 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
917 WATCHDOG_RESET();
918 anti_pattern = ~pattern;
Simon Glass5512d5b2013-02-28 17:47:14 +0000919 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000920 if (temp != anti_pattern) {
Simon Glassc9638f52013-02-24 17:33:16 +0000921 printf("\nFAILURE (read/write): @ 0x%.8lx:"
wdenk38635852002-08-27 05:55:31 +0000922 " expected 0x%.8lx, actual 0x%.8lx)\n",
David Feng102c0512014-02-12 16:10:08 +0800923 start_addr + offset*sizeof(vu_long),
924 anti_pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400925 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000926 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000927 return -1;
wdenk38635852002-08-27 05:55:31 +0000928 }
Simon Glass5512d5b2013-02-28 17:47:14 +0000929 addr[offset] = 0;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000930 }
Simon Glass51209b12013-02-24 17:33:17 +0000931
932 return 0;
Simon Glassc9638f52013-02-24 17:33:16 +0000933}
wdenk38635852002-08-27 05:55:31 +0000934
Simon Glass5512d5b2013-02-28 17:47:14 +0000935static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
936 vu_long pattern, int iteration)
Simon Glassc9638f52013-02-24 17:33:16 +0000937{
Simon Glass5512d5b2013-02-28 17:47:14 +0000938 vu_long *end;
Simon Glassc9638f52013-02-24 17:33:16 +0000939 vu_long *addr;
Simon Glassc9638f52013-02-24 17:33:16 +0000940 ulong errs = 0;
Simon Glass5512d5b2013-02-28 17:47:14 +0000941 ulong incr, length;
Simon Glassc9638f52013-02-24 17:33:16 +0000942 ulong val, readback;
943
Simon Glass51209b12013-02-24 17:33:17 +0000944 /* Alternate the pattern */
wdenk38635852002-08-27 05:55:31 +0000945 incr = 1;
Simon Glass51209b12013-02-24 17:33:17 +0000946 if (iteration & 1) {
947 incr = -incr;
948 /*
949 * Flip the pattern each time to make lots of zeros and
950 * then, the next time, lots of ones. We decrement
951 * the "negative" patterns and increment the "positive"
952 * patterns to preserve this feature.
953 */
954 if (pattern & 0x80000000)
955 pattern = -pattern; /* complement & increment */
956 else
957 pattern = ~pattern;
958 }
Simon Glass5512d5b2013-02-28 17:47:14 +0000959 length = (end_addr - start_addr) / sizeof(ulong);
960 end = buf + length;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000961 printf("\rPattern %08lX Writing..."
962 "%12s"
963 "\b\b\b\b\b\b\b\b\b\b",
964 pattern, "");
wdenk38635852002-08-27 05:55:31 +0000965
Simon Glass5512d5b2013-02-28 17:47:14 +0000966 for (addr = buf, val = pattern; addr < end; addr++) {
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000967 WATCHDOG_RESET();
968 *addr = val;
969 val += incr;
970 }
wdenk38635852002-08-27 05:55:31 +0000971
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000972 puts("Reading...");
wdenk38635852002-08-27 05:55:31 +0000973
Simon Glass5512d5b2013-02-28 17:47:14 +0000974 for (addr = buf, val = pattern; addr < end; addr++) {
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000975 WATCHDOG_RESET();
976 readback = *addr;
977 if (readback != val) {
Simon Glass5512d5b2013-02-28 17:47:14 +0000978 ulong offset = addr - buf;
979
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000980 printf("\nMem error @ 0x%08X: "
981 "found %08lX, expected %08lX\n",
David Feng102c0512014-02-12 16:10:08 +0800982 (uint)(uintptr_t)(start_addr + offset*sizeof(vu_long)),
Simon Glass5512d5b2013-02-28 17:47:14 +0000983 readback, val);
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000984 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000985 if (ctrlc())
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000986 return -1;
wdenk38635852002-08-27 05:55:31 +0000987 }
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000988 val += incr;
989 }
wdenk38635852002-08-27 05:55:31 +0000990
Simon Glass51209b12013-02-24 17:33:17 +0000991 return 0;
Simon Glassc9638f52013-02-24 17:33:16 +0000992}
993
994/*
995 * Perform a memory test. A more complete alternative test can be
996 * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
997 * interrupted by ctrl-c or by a failure of one of the sub-tests.
998 */
999static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
1000 char * const argv[])
1001{
Simon Glass8c86bbe2013-02-24 17:33:20 +00001002 ulong start, end;
Simon Glass5512d5b2013-02-28 17:47:14 +00001003 vu_long *buf, *dummy;
Tom Riniadcc5702015-04-07 09:38:54 -04001004 ulong iteration_limit = 0;
Simon Glassc9638f52013-02-24 17:33:16 +00001005 int ret;
Simon Glass51209b12013-02-24 17:33:17 +00001006 ulong errs = 0; /* number of errors, or -1 if interrupted */
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001007 ulong pattern = 0;
Simon Glass51209b12013-02-24 17:33:17 +00001008 int iteration;
Simon Glassc9638f52013-02-24 17:33:16 +00001009#if defined(CONFIG_SYS_ALT_MEMTEST)
1010 const int alt_test = 1;
1011#else
1012 const int alt_test = 0;
wdenk38635852002-08-27 05:55:31 +00001013#endif
Simon Glassc9638f52013-02-24 17:33:16 +00001014
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001015 start = CONFIG_SYS_MEMTEST_START;
1016 end = CONFIG_SYS_MEMTEST_END;
1017
Simon Glassc9638f52013-02-24 17:33:16 +00001018 if (argc > 1)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001019 if (strict_strtoul(argv[1], 16, &start) < 0)
1020 return CMD_RET_USAGE;
Simon Glassc9638f52013-02-24 17:33:16 +00001021
1022 if (argc > 2)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001023 if (strict_strtoul(argv[2], 16, &end) < 0)
1024 return CMD_RET_USAGE;
Simon Glassc9638f52013-02-24 17:33:16 +00001025
1026 if (argc > 3)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001027 if (strict_strtoul(argv[3], 16, &pattern) < 0)
1028 return CMD_RET_USAGE;
Simon Glassc9638f52013-02-24 17:33:16 +00001029
1030 if (argc > 4)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001031 if (strict_strtoul(argv[4], 16, &iteration_limit) < 0)
1032 return CMD_RET_USAGE;
1033
1034 if (end < start) {
1035 printf("Refusing to do empty test\n");
1036 return -1;
1037 }
Simon Glassc9638f52013-02-24 17:33:16 +00001038
Simon Glass8c86bbe2013-02-24 17:33:20 +00001039 printf("Testing %08x ... %08x:\n", (uint)start, (uint)end);
1040 debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__,
1041 start, end);
Simon Glass51209b12013-02-24 17:33:17 +00001042
Simon Glass5512d5b2013-02-28 17:47:14 +00001043 buf = map_sysmem(start, end - start);
1044 dummy = map_sysmem(CONFIG_SYS_MEMTEST_SCRATCH, sizeof(vu_long));
Simon Glass51209b12013-02-24 17:33:17 +00001045 for (iteration = 0;
1046 !iteration_limit || iteration < iteration_limit;
1047 iteration++) {
1048 if (ctrlc()) {
Simon Glass51209b12013-02-24 17:33:17 +00001049 errs = -1UL;
1050 break;
1051 }
1052
1053 printf("Iteration: %6d\r", iteration + 1);
1054 debug("\n");
Simon Glass5512d5b2013-02-28 17:47:14 +00001055 if (alt_test) {
1056 errs = mem_test_alt(buf, start, end, dummy);
1057 } else {
1058 errs = mem_test_quick(buf, start, end, pattern,
1059 iteration);
1060 }
1061 if (errs == -1UL)
1062 break;
1063 }
1064
1065 /*
1066 * Work-around for eldk-4.2 which gives this warning if we try to
1067 * case in the unmap_sysmem() call:
1068 * warning: initialization discards qualifiers from pointer target type
1069 */
1070 {
1071 void *vbuf = (void *)buf;
1072 void *vdummy = (void *)dummy;
1073
1074 unmap_sysmem(vbuf);
1075 unmap_sysmem(vdummy);
Simon Glass51209b12013-02-24 17:33:17 +00001076 }
1077
1078 if (errs == -1UL) {
Simon Glassc44d4382013-02-24 17:33:19 +00001079 /* Memory test was aborted - write a newline to finish off */
1080 putc('\n');
Simon Glass51209b12013-02-24 17:33:17 +00001081 ret = 1;
1082 } else {
1083 printf("Tested %d iteration(s) with %lu errors.\n",
1084 iteration, errs);
1085 ret = errs != 0;
1086 }
Simon Glassc9638f52013-02-24 17:33:16 +00001087
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001088 return ret;
wdenk38635852002-08-27 05:55:31 +00001089}
Wolfgang Denka2681702013-03-08 10:51:32 +00001090#endif /* CONFIG_CMD_MEMTEST */
wdenk38635852002-08-27 05:55:31 +00001091
1092/* Modify memory.
1093 *
1094 * Syntax:
York Sun4d1fd7f2014-02-26 17:03:19 -08001095 * mm{.b, .w, .l, .q} {addr}
1096 * nm{.b, .w, .l, .q} {addr}
wdenk38635852002-08-27 05:55:31 +00001097 */
1098static int
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001099mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +00001100{
York Sun4d1fd7f2014-02-26 17:03:19 -08001101 ulong addr;
1102#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1103 u64 i;
1104#else
1105 ulong i;
1106#endif
wdenk27b207f2003-07-24 23:38:38 +00001107 int nbytes, size;
Simon Glass0628ab82013-02-24 17:33:15 +00001108 void *ptr = NULL;
wdenk38635852002-08-27 05:55:31 +00001109
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001110 if (argc != 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001111 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +00001112
Simon Glassb26440f2014-04-10 20:01:31 -06001113 bootretry_reset_cmd_timeout(); /* got a good command to get here */
wdenk38635852002-08-27 05:55:31 +00001114 /* We use the last specified parameters, unless new ones are
1115 * entered.
1116 */
1117 addr = mm_last_addr;
1118 size = mm_last_size;
1119
1120 if ((flag & CMD_FLAG_REPEAT) == 0) {
1121 /* New command specified. Check for a size specification.
1122 * Defaults to long if no or incorrect specification.
1123 */
wdenk27b207f2003-07-24 23:38:38 +00001124 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
1125 return 1;
wdenk38635852002-08-27 05:55:31 +00001126
1127 /* Address is specified since argc > 1
1128 */
1129 addr = simple_strtoul(argv[1], NULL, 16);
1130 addr += base_address;
1131 }
1132
wdenk2abbe072003-06-16 23:50:08 +00001133#ifdef CONFIG_HAS_DATAFLASH
1134 if (addr_dataflash(addr)){
wdenk4b9206e2004-03-23 22:14:11 +00001135 puts ("Can't modify DataFlash in place. Use cp instead.\n\r");
wdenk2abbe072003-06-16 23:50:08 +00001136 return 0;
1137 }
1138#endif
1139
Mike Frysinger4c727c72008-02-04 19:26:56 -05001140#ifdef CONFIG_BLACKFIN
1141 if (addr_bfin_on_chip_mem(addr)) {
1142 puts ("Can't modify L1 instruction in place. Use cp instead.\n\r");
1143 return 0;
1144 }
1145#endif
1146
wdenk38635852002-08-27 05:55:31 +00001147 /* Print the address, followed by value. Then accept input for
1148 * the next value. A non-converted value exits.
1149 */
1150 do {
Simon Glass0628ab82013-02-24 17:33:15 +00001151 ptr = map_sysmem(addr, size);
wdenk38635852002-08-27 05:55:31 +00001152 printf("%08lx:", addr);
1153 if (size == 4)
York Sun76698b42014-02-12 15:55:35 -08001154 printf(" %08x", *((u32 *)ptr));
York Sun4d1fd7f2014-02-26 17:03:19 -08001155#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1156 else if (size == 8)
Simon Glasse48f3742014-11-11 12:47:07 -07001157 printf(" %016" PRIx64, *((u64 *)ptr));
York Sun4d1fd7f2014-02-26 17:03:19 -08001158#endif
wdenk38635852002-08-27 05:55:31 +00001159 else if (size == 2)
York Sun76698b42014-02-12 15:55:35 -08001160 printf(" %04x", *((u16 *)ptr));
wdenk38635852002-08-27 05:55:31 +00001161 else
York Sun76698b42014-02-12 15:55:35 -08001162 printf(" %02x", *((u8 *)ptr));
wdenk38635852002-08-27 05:55:31 +00001163
Simon Glasse1bf8242014-04-10 20:01:27 -06001164 nbytes = cli_readline(" ? ");
wdenk38635852002-08-27 05:55:31 +00001165 if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
1166 /* <CR> pressed as only input, don't modify current
1167 * location and move to next. "-" pressed will go back.
1168 */
1169 if (incrflag)
1170 addr += nbytes ? -size : size;
1171 nbytes = 1;
Simon Glassb26440f2014-04-10 20:01:31 -06001172 /* good enough to not time out */
1173 bootretry_reset_cmd_timeout();
wdenk38635852002-08-27 05:55:31 +00001174 }
1175#ifdef CONFIG_BOOT_RETRY_TIME
1176 else if (nbytes == -2) {
1177 break; /* timed out, exit the command */
1178 }
1179#endif
1180 else {
1181 char *endp;
York Sun4d1fd7f2014-02-26 17:03:19 -08001182#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1183 i = simple_strtoull(console_buffer, &endp, 16);
1184#else
wdenk38635852002-08-27 05:55:31 +00001185 i = simple_strtoul(console_buffer, &endp, 16);
York Sun4d1fd7f2014-02-26 17:03:19 -08001186#endif
wdenk38635852002-08-27 05:55:31 +00001187 nbytes = endp - console_buffer;
1188 if (nbytes) {
wdenk38635852002-08-27 05:55:31 +00001189 /* good enough to not time out
1190 */
Simon Glassb26440f2014-04-10 20:01:31 -06001191 bootretry_reset_cmd_timeout();
wdenk38635852002-08-27 05:55:31 +00001192 if (size == 4)
York Sun76698b42014-02-12 15:55:35 -08001193 *((u32 *)ptr) = i;
York Sun4d1fd7f2014-02-26 17:03:19 -08001194#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1195 else if (size == 8)
1196 *((u64 *)ptr) = i;
1197#endif
wdenk38635852002-08-27 05:55:31 +00001198 else if (size == 2)
York Sun76698b42014-02-12 15:55:35 -08001199 *((u16 *)ptr) = i;
wdenk38635852002-08-27 05:55:31 +00001200 else
York Sun76698b42014-02-12 15:55:35 -08001201 *((u8 *)ptr) = i;
wdenk38635852002-08-27 05:55:31 +00001202 if (incrflag)
1203 addr += size;
1204 }
1205 }
1206 } while (nbytes);
Simon Glass0628ab82013-02-24 17:33:15 +00001207 if (ptr)
1208 unmap_sysmem(ptr);
wdenk38635852002-08-27 05:55:31 +00001209
1210 mm_last_addr = addr;
1211 mm_last_size = size;
1212 return 0;
1213}
1214
Mike Frysinger710b9932010-12-21 14:19:51 -05001215#ifdef CONFIG_CMD_CRC32
1216
Kim Phillips088f1b12012-10-29 13:34:31 +00001217static int do_mem_crc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +00001218{
Simon Glassd20a40d2013-02-24 20:30:22 +00001219 int flags = 0;
1220 int ac;
1221 char * const *av;
wdenk38635852002-08-27 05:55:31 +00001222
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001223 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001224 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +00001225
wdenkc26e4542004-04-18 10:13:26 +00001226 av = argv + 1;
1227 ac = argc - 1;
Simon Glassd20a40d2013-02-24 20:30:22 +00001228#ifdef CONFIG_HASH_VERIFY
wdenkc26e4542004-04-18 10:13:26 +00001229 if (strcmp(*av, "-v") == 0) {
Simon Glassd20a40d2013-02-24 20:30:22 +00001230 flags |= HASH_FLAG_VERIFY;
wdenkc26e4542004-04-18 10:13:26 +00001231 av++;
1232 ac--;
wdenkc26e4542004-04-18 10:13:26 +00001233 }
Simon Glassd20a40d2013-02-24 20:30:22 +00001234#endif
wdenkc26e4542004-04-18 10:13:26 +00001235
Simon Glassd20a40d2013-02-24 20:30:22 +00001236 return hash_command("crc32", flags, cmdtp, flag, ac, av);
wdenkc26e4542004-04-18 10:13:26 +00001237}
wdenkc26e4542004-04-18 10:13:26 +00001238
Mike Frysinger710b9932010-12-21 14:19:51 -05001239#endif
1240
wdenk8bde7f72003-06-27 21:31:46 +00001241/**************************************************/
wdenk0d498392003-07-01 21:06:45 +00001242U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001243 md, 3, 1, do_mem_md,
Peter Tyser2fb26042009-01-27 18:03:12 -06001244 "memory display",
York Sun4d1fd7f2014-02-26 17:03:19 -08001245#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1246 "[.b, .w, .l, .q] address [# of objects]"
1247#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001248 "[.b, .w, .l] address [# of objects]"
York Sun4d1fd7f2014-02-26 17:03:19 -08001249#endif
wdenk8bde7f72003-06-27 21:31:46 +00001250);
1251
1252
wdenk0d498392003-07-01 21:06:45 +00001253U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001254 mm, 2, 1, do_mem_mm,
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001255 "memory modify (auto-incrementing address)",
York Sun4d1fd7f2014-02-26 17:03:19 -08001256#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1257 "[.b, .w, .l, .q] address"
1258#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001259 "[.b, .w, .l] address"
York Sun4d1fd7f2014-02-26 17:03:19 -08001260#endif
wdenk8bde7f72003-06-27 21:31:46 +00001261);
1262
1263
wdenk0d498392003-07-01 21:06:45 +00001264U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001265 nm, 2, 1, do_mem_nm,
Peter Tyser2fb26042009-01-27 18:03:12 -06001266 "memory modify (constant address)",
York Sun4d1fd7f2014-02-26 17:03:19 -08001267#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1268 "[.b, .w, .l, .q] address"
1269#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001270 "[.b, .w, .l] address"
York Sun4d1fd7f2014-02-26 17:03:19 -08001271#endif
wdenk8bde7f72003-06-27 21:31:46 +00001272);
1273
wdenk0d498392003-07-01 21:06:45 +00001274U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001275 mw, 4, 1, do_mem_mw,
Peter Tyser2fb26042009-01-27 18:03:12 -06001276 "memory write (fill)",
York Sun4d1fd7f2014-02-26 17:03:19 -08001277#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1278 "[.b, .w, .l, .q] address value [count]"
1279#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001280 "[.b, .w, .l] address value [count]"
York Sun4d1fd7f2014-02-26 17:03:19 -08001281#endif
wdenk8bde7f72003-06-27 21:31:46 +00001282);
1283
wdenk0d498392003-07-01 21:06:45 +00001284U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001285 cp, 4, 1, do_mem_cp,
Peter Tyser2fb26042009-01-27 18:03:12 -06001286 "memory copy",
York Sun4d1fd7f2014-02-26 17:03:19 -08001287#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1288 "[.b, .w, .l, .q] source target count"
1289#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001290 "[.b, .w, .l] source target count"
York Sun4d1fd7f2014-02-26 17:03:19 -08001291#endif
wdenk8bde7f72003-06-27 21:31:46 +00001292);
1293
wdenk0d498392003-07-01 21:06:45 +00001294U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001295 cmp, 4, 1, do_mem_cmp,
Peter Tyser2fb26042009-01-27 18:03:12 -06001296 "memory compare",
York Sun4d1fd7f2014-02-26 17:03:19 -08001297#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1298 "[.b, .w, .l, .q] addr1 addr2 count"
1299#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001300 "[.b, .w, .l] addr1 addr2 count"
York Sun4d1fd7f2014-02-26 17:03:19 -08001301#endif
wdenk8bde7f72003-06-27 21:31:46 +00001302);
1303
Mike Frysinger710b9932010-12-21 14:19:51 -05001304#ifdef CONFIG_CMD_CRC32
1305
wdenkc26e4542004-04-18 10:13:26 +00001306#ifndef CONFIG_CRC32_VERIFY
1307
wdenk0d498392003-07-01 21:06:45 +00001308U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001309 crc32, 4, 1, do_mem_crc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001310 "checksum calculation",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001311 "address count [addr]\n - compute CRC32 checksum [save at addr]"
wdenk8bde7f72003-06-27 21:31:46 +00001312);
1313
wdenkc26e4542004-04-18 10:13:26 +00001314#else /* CONFIG_CRC32_VERIFY */
1315
1316U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001317 crc32, 5, 1, do_mem_crc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001318 "checksum calculation",
wdenkc26e4542004-04-18 10:13:26 +00001319 "address count [addr]\n - compute CRC32 checksum [save at addr]\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001320 "-v address count crc\n - verify crc of memory area"
wdenkc26e4542004-04-18 10:13:26 +00001321);
1322
1323#endif /* CONFIG_CRC32_VERIFY */
1324
Mike Frysinger710b9932010-12-21 14:19:51 -05001325#endif
1326
Simon Glass15a33e42012-11-30 13:01:20 +00001327#ifdef CONFIG_CMD_MEMINFO
1328__weak void board_show_dram(ulong size)
1329{
1330 puts("DRAM: ");
1331 print_size(size, "\n");
1332}
1333
1334static int do_mem_info(cmd_tbl_t *cmdtp, int flag, int argc,
1335 char * const argv[])
1336{
1337 board_show_dram(gd->ram_size);
1338
1339 return 0;
1340}
1341#endif
1342
wdenk0d498392003-07-01 21:06:45 +00001343U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001344 base, 2, 1, do_mem_base,
Peter Tyser2fb26042009-01-27 18:03:12 -06001345 "print or set address offset",
wdenk8bde7f72003-06-27 21:31:46 +00001346 "\n - print address offset for memory commands\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001347 "base off\n - set address offset for memory commands to 'off'"
wdenk8bde7f72003-06-27 21:31:46 +00001348);
1349
wdenk0d498392003-07-01 21:06:45 +00001350U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001351 loop, 3, 1, do_mem_loop,
Peter Tyser2fb26042009-01-27 18:03:12 -06001352 "infinite loop on address range",
York Sun4d1fd7f2014-02-26 17:03:19 -08001353#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1354 "[.b, .w, .l, .q] address number_of_objects"
1355#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001356 "[.b, .w, .l] address number_of_objects"
York Sun4d1fd7f2014-02-26 17:03:19 -08001357#endif
wdenk8bde7f72003-06-27 21:31:46 +00001358);
1359
wdenk56523f12004-07-11 17:40:54 +00001360#ifdef CONFIG_LOOPW
1361U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001362 loopw, 4, 1, do_mem_loopw,
Peter Tyser2fb26042009-01-27 18:03:12 -06001363 "infinite write loop on address range",
York Sun4d1fd7f2014-02-26 17:03:19 -08001364#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1365 "[.b, .w, .l, .q] address number_of_objects data_to_write"
1366#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001367 "[.b, .w, .l] address number_of_objects data_to_write"
York Sun4d1fd7f2014-02-26 17:03:19 -08001368#endif
wdenk56523f12004-07-11 17:40:54 +00001369);
1370#endif /* CONFIG_LOOPW */
1371
Wolfgang Denka2681702013-03-08 10:51:32 +00001372#ifdef CONFIG_CMD_MEMTEST
wdenk0d498392003-07-01 21:06:45 +00001373U_BOOT_CMD(
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +01001374 mtest, 5, 1, do_mem_mtest,
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001375 "simple RAM read/write test",
1376 "[start [end [pattern [iterations]]]]"
wdenk8bde7f72003-06-27 21:31:46 +00001377);
Wolfgang Denka2681702013-03-08 10:51:32 +00001378#endif /* CONFIG_CMD_MEMTEST */
wdenk8bde7f72003-06-27 21:31:46 +00001379
stroese4aaf29b2004-12-16 17:42:39 +00001380#ifdef CONFIG_MX_CYCLIC
1381U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001382 mdc, 4, 1, do_mem_mdc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001383 "memory display cyclic",
York Sun4d1fd7f2014-02-26 17:03:19 -08001384#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1385 "[.b, .w, .l, .q] address count delay(ms)"
1386#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001387 "[.b, .w, .l] address count delay(ms)"
York Sun4d1fd7f2014-02-26 17:03:19 -08001388#endif
stroese4aaf29b2004-12-16 17:42:39 +00001389);
1390
1391U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001392 mwc, 4, 1, do_mem_mwc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001393 "memory write cyclic",
York Sun4d1fd7f2014-02-26 17:03:19 -08001394#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1395 "[.b, .w, .l, .q] address value delay(ms)"
1396#else
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001397 "[.b, .w, .l] address value delay(ms)"
York Sun4d1fd7f2014-02-26 17:03:19 -08001398#endif
stroese4aaf29b2004-12-16 17:42:39 +00001399);
1400#endif /* CONFIG_MX_CYCLIC */
Simon Glass15a33e42012-11-30 13:01:20 +00001401
1402#ifdef CONFIG_CMD_MEMINFO
1403U_BOOT_CMD(
1404 meminfo, 3, 1, do_mem_info,
1405 "display memory information",
1406 ""
1407);
1408#endif