blob: 1eb83b757030526487df1477910e4ef0bcc078d7 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk38635852002-08-27 05:55:31 +00002/*
3 * (C) Copyright 2000
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
wdenk38635852002-08-27 05:55:31 +00005 */
6
7/*
8 * Memory Functions
9 *
10 * Copied from FADS ROM, Dan Malek (dmalek@jlc.net)
11 */
12
13#include <common.h>
Simon Glass24b852a2015-11-08 23:47:45 -070014#include <console.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>
Simon Glass24b852a2015-11-08 23:47:45 -070018#include <console.h>
Simon Glass0ee482522019-12-28 10:44:40 -070019#include <flash.h>
Simon Glassd20a40d2013-02-24 20:30:22 +000020#include <hash.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060021#include <log.h>
Joe Hershberger0eb25b62015-03-22 17:08:59 -050022#include <mapmem.h>
Simon Glass90526e92020-05-10 11:39:56 -060023#include <rand.h>
Sergei Poselenova6e6fc62008-04-09 16:09:41 +020024#include <watchdog.h>
Simon Glass401d1c42020-10-30 21:38:53 -060025#include <asm/global_data.h>
Simon Glass0628ab82013-02-24 17:33:15 +000026#include <asm/io.h>
Simon Glasscd93d622020-05-10 11:40:13 -060027#include <linux/bitops.h>
Simon Glass15a33e42012-11-30 13:01:20 +000028#include <linux/compiler.h>
Simon Glassbdded202020-06-02 19:26:49 -060029#include <linux/ctype.h>
Simon Glassc05ed002020-05-10 11:40:11 -060030#include <linux/delay.h>
Simon Glass15a33e42012-11-30 13:01:20 +000031
32DECLARE_GLOBAL_DATA_PTR;
wdenk38635852002-08-27 05:55:31 +000033
Simon Glass76be8f72020-06-02 19:26:45 -060034/* Create a compile-time value */
Simon Glass46809762020-06-02 19:26:46 -060035#ifdef MEM_SUPPORT_64BIT_DATA
36#define SUPPORT_64BIT_DATA 1
Simon Glass76be8f72020-06-02 19:26:45 -060037#define HELP_Q ", .q"
38#else
Simon Glass46809762020-06-02 19:26:46 -060039#define SUPPORT_64BIT_DATA 0
Simon Glass76be8f72020-06-02 19:26:45 -060040#define HELP_Q ""
41#endif
42
Simon Glass09140112020-05-10 11:40:03 -060043static int mod_mem(struct cmd_tbl *, int, int, int, char * const []);
wdenk38635852002-08-27 05:55:31 +000044
45/* Display values from last command.
46 * Memory modify remembered values are different from display memory.
47 */
Scott Wood581508b2015-03-19 09:43:12 -070048static ulong dp_last_addr, dp_last_size;
49static ulong dp_last_length = 0x40;
50static ulong mm_last_addr, mm_last_size;
wdenk38635852002-08-27 05:55:31 +000051
52static ulong base_address = 0;
Simon Glass550a9e72020-07-28 19:41:14 -060053#ifdef CONFIG_CMD_MEM_SEARCH
54static ulong dp_last_ms_length;
Simon Glassbdded202020-06-02 19:26:49 -060055static u8 search_buf[64];
56static uint search_len;
57#endif
wdenk38635852002-08-27 05:55:31 +000058
59/* Memory Display
60 *
61 * Syntax:
York Sun4d1fd7f2014-02-26 17:03:19 -080062 * md{.b, .w, .l, .q} {addr} {len}
wdenk38635852002-08-27 05:55:31 +000063 */
64#define DISP_LINE_LEN 16
Simon Glass09140112020-05-10 11:40:03 -060065static int do_mem_md(struct cmd_tbl *cmdtp, int flag, int argc,
66 char *const argv[])
wdenk38635852002-08-27 05:55:31 +000067{
Tuomas Tynkkynenc68c03f2017-10-10 21:59:42 +030068 ulong addr, length, bytes;
69 const void *buf;
wdenk27b207f2003-07-24 23:38:38 +000070 int size;
wdenk38635852002-08-27 05:55:31 +000071 int rc = 0;
72
73 /* We use the last specified parameters, unless new ones are
74 * entered.
75 */
76 addr = dp_last_addr;
77 size = dp_last_size;
78 length = dp_last_length;
79
Wolfgang Denk47e26b12010-07-17 01:06:04 +020080 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +000081 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +000082
83 if ((flag & CMD_FLAG_REPEAT) == 0) {
84 /* New command specified. Check for a size specification.
85 * Defaults to long if no or incorrect specification.
86 */
wdenk27b207f2003-07-24 23:38:38 +000087 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
88 return 1;
wdenk38635852002-08-27 05:55:31 +000089
90 /* Address is specified since argc > 1
91 */
92 addr = simple_strtoul(argv[1], NULL, 16);
93 addr += base_address;
94
95 /* If another parameter, it is the length to display.
96 * Length is the number of objects, not number of bytes.
97 */
98 if (argc > 2)
99 length = simple_strtoul(argv[2], NULL, 16);
100 }
101
Tuomas Tynkkynenc68c03f2017-10-10 21:59:42 +0300102 bytes = size * length;
103 buf = map_sysmem(addr, bytes);
wdenk2abbe072003-06-16 23:50:08 +0000104
Tuomas Tynkkynenc68c03f2017-10-10 21:59:42 +0300105 /* Print the lines. */
106 print_buffer(addr, buf, size, length, DISP_LINE_LEN / size);
107 addr += bytes;
108 unmap_sysmem(buf);
wdenk38635852002-08-27 05:55:31 +0000109
110 dp_last_addr = addr;
111 dp_last_length = length;
112 dp_last_size = size;
113 return (rc);
114}
115
Simon Glass09140112020-05-10 11:40:03 -0600116static int do_mem_mm(struct cmd_tbl *cmdtp, int flag, int argc,
117 char *const argv[])
wdenk38635852002-08-27 05:55:31 +0000118{
119 return mod_mem (cmdtp, 1, flag, argc, argv);
120}
Simon Glass09140112020-05-10 11:40:03 -0600121
122static int do_mem_nm(struct cmd_tbl *cmdtp, int flag, int argc,
123 char *const argv[])
wdenk38635852002-08-27 05:55:31 +0000124{
125 return mod_mem (cmdtp, 0, flag, argc, argv);
126}
127
Simon Glass09140112020-05-10 11:40:03 -0600128static int do_mem_mw(struct cmd_tbl *cmdtp, int flag, int argc,
129 char *const argv[])
wdenk38635852002-08-27 05:55:31 +0000130{
Simon Glass46809762020-06-02 19:26:46 -0600131 ulong writeval; /* 64-bit if SUPPORT_64BIT_DATA */
York Sun4d1fd7f2014-02-26 17:03:19 -0800132 ulong addr, count;
wdenk27b207f2003-07-24 23:38:38 +0000133 int size;
Simon Glasscc5e1962015-03-05 12:25:18 -0700134 void *buf, *start;
Simon Glass0628ab82013-02-24 17:33:15 +0000135 ulong bytes;
wdenk38635852002-08-27 05:55:31 +0000136
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200137 if ((argc < 3) || (argc > 4))
Simon Glass4c12eeb2011-12-10 08:44:01 +0000138 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000139
140 /* Check for size specification.
141 */
wdenk27b207f2003-07-24 23:38:38 +0000142 if ((size = cmd_get_data_size(argv[0], 4)) < 1)
143 return 1;
wdenk38635852002-08-27 05:55:31 +0000144
145 /* Address is specified since argc > 1
146 */
147 addr = simple_strtoul(argv[1], NULL, 16);
148 addr += base_address;
149
150 /* Get the value to write.
151 */
Simon Glass46809762020-06-02 19:26:46 -0600152 if (SUPPORT_64BIT_DATA)
153 writeval = simple_strtoull(argv[2], NULL, 16);
154 else
155 writeval = simple_strtoul(argv[2], NULL, 16);
wdenk38635852002-08-27 05:55:31 +0000156
157 /* Count ? */
158 if (argc == 4) {
159 count = simple_strtoul(argv[3], NULL, 16);
160 } else {
161 count = 1;
162 }
163
Simon Glass0628ab82013-02-24 17:33:15 +0000164 bytes = size * count;
Simon Glasscc5e1962015-03-05 12:25:18 -0700165 start = map_sysmem(addr, bytes);
166 buf = start;
wdenk38635852002-08-27 05:55:31 +0000167 while (count-- > 0) {
168 if (size == 4)
York Sun76698b42014-02-12 15:55:35 -0800169 *((u32 *)buf) = (u32)writeval;
Simon Glass46809762020-06-02 19:26:46 -0600170 else if (SUPPORT_64BIT_DATA && size == 8)
171 *((ulong *)buf) = writeval;
wdenk38635852002-08-27 05:55:31 +0000172 else if (size == 2)
York Sun76698b42014-02-12 15:55:35 -0800173 *((u16 *)buf) = (u16)writeval;
wdenk38635852002-08-27 05:55:31 +0000174 else
York Sun76698b42014-02-12 15:55:35 -0800175 *((u8 *)buf) = (u8)writeval;
Simon Glass0628ab82013-02-24 17:33:15 +0000176 buf += size;
wdenk38635852002-08-27 05:55:31 +0000177 }
Simon Glasscc5e1962015-03-05 12:25:18 -0700178 unmap_sysmem(start);
wdenk38635852002-08-27 05:55:31 +0000179 return 0;
180}
181
Joel Johnson72732312020-01-29 09:17:18 -0700182#ifdef CONFIG_CMD_MX_CYCLIC
Simon Glass09140112020-05-10 11:40:03 -0600183static int do_mem_mdc(struct cmd_tbl *cmdtp, int flag, int argc,
184 char *const argv[])
stroese4aaf29b2004-12-16 17:42:39 +0000185{
186 int i;
187 ulong count;
188
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200189 if (argc < 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000190 return CMD_RET_USAGE;
stroese4aaf29b2004-12-16 17:42:39 +0000191
192 count = simple_strtoul(argv[3], NULL, 10);
193
194 for (;;) {
195 do_mem_md (NULL, 0, 3, argv);
196
197 /* delay for <count> ms... */
198 for (i=0; i<count; i++)
Simon Glass07e11142020-05-10 11:40:10 -0600199 udelay(1000);
stroese4aaf29b2004-12-16 17:42:39 +0000200
201 /* check for ctrl-c to abort... */
202 if (ctrlc()) {
203 puts("Abort\n");
204 return 0;
205 }
206 }
207
208 return 0;
209}
210
Simon Glass09140112020-05-10 11:40:03 -0600211static int do_mem_mwc(struct cmd_tbl *cmdtp, int flag, int argc,
212 char *const argv[])
stroese4aaf29b2004-12-16 17:42:39 +0000213{
214 int i;
215 ulong count;
216
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200217 if (argc < 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000218 return CMD_RET_USAGE;
stroese4aaf29b2004-12-16 17:42:39 +0000219
220 count = simple_strtoul(argv[3], NULL, 10);
221
222 for (;;) {
223 do_mem_mw (NULL, 0, 3, argv);
224
225 /* delay for <count> ms... */
226 for (i=0; i<count; i++)
Simon Glass07e11142020-05-10 11:40:10 -0600227 udelay(1000);
stroese4aaf29b2004-12-16 17:42:39 +0000228
229 /* check for ctrl-c to abort... */
230 if (ctrlc()) {
231 puts("Abort\n");
232 return 0;
233 }
234 }
235
236 return 0;
237}
Joel Johnson72732312020-01-29 09:17:18 -0700238#endif /* CONFIG_CMD_MX_CYCLIC */
stroese4aaf29b2004-12-16 17:42:39 +0000239
Simon Glass09140112020-05-10 11:40:03 -0600240static int do_mem_cmp(struct cmd_tbl *cmdtp, int flag, int argc,
241 char *const argv[])
wdenk38635852002-08-27 05:55:31 +0000242{
Simon Glass0628ab82013-02-24 17:33:15 +0000243 ulong addr1, addr2, count, ngood, bytes;
wdenk27b207f2003-07-24 23:38:38 +0000244 int size;
wdenk38635852002-08-27 05:55:31 +0000245 int rcode = 0;
Mike Frysinger054ea172012-01-20 09:07:21 +0000246 const char *type;
Simon Glass0628ab82013-02-24 17:33:15 +0000247 const void *buf1, *buf2, *base;
Simon Glass46809762020-06-02 19:26:46 -0600248 ulong word1, word2; /* 64-bit if SUPPORT_64BIT_DATA */
wdenk38635852002-08-27 05:55:31 +0000249
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200250 if (argc != 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000251 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000252
253 /* Check for size specification.
254 */
wdenk27b207f2003-07-24 23:38:38 +0000255 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
256 return 1;
York Sun4d1fd7f2014-02-26 17:03:19 -0800257 type = size == 8 ? "double word" :
258 size == 4 ? "word" :
259 size == 2 ? "halfword" : "byte";
wdenk38635852002-08-27 05:55:31 +0000260
261 addr1 = simple_strtoul(argv[1], NULL, 16);
262 addr1 += base_address;
263
264 addr2 = simple_strtoul(argv[2], NULL, 16);
265 addr2 += base_address;
266
267 count = simple_strtoul(argv[3], NULL, 16);
268
Simon Glass0628ab82013-02-24 17:33:15 +0000269 bytes = size * count;
270 base = buf1 = map_sysmem(addr1, bytes);
271 buf2 = map_sysmem(addr2, bytes);
Mike Frysingerfeb12a12012-01-20 09:07:22 +0000272 for (ngood = 0; ngood < count; ++ngood) {
wdenk38635852002-08-27 05:55:31 +0000273 if (size == 4) {
York Sun76698b42014-02-12 15:55:35 -0800274 word1 = *(u32 *)buf1;
275 word2 = *(u32 *)buf2;
Simon Glass46809762020-06-02 19:26:46 -0600276 } else if (SUPPORT_64BIT_DATA && size == 8) {
277 word1 = *(ulong *)buf1;
278 word2 = *(ulong *)buf2;
Mike Frysinger054ea172012-01-20 09:07:21 +0000279 } else if (size == 2) {
York Sun76698b42014-02-12 15:55:35 -0800280 word1 = *(u16 *)buf1;
281 word2 = *(u16 *)buf2;
Mike Frysinger054ea172012-01-20 09:07:21 +0000282 } else {
York Sun76698b42014-02-12 15:55:35 -0800283 word1 = *(u8 *)buf1;
284 word2 = *(u8 *)buf2;
wdenk38635852002-08-27 05:55:31 +0000285 }
Mike Frysinger054ea172012-01-20 09:07:21 +0000286 if (word1 != word2) {
Simon Glass0628ab82013-02-24 17:33:15 +0000287 ulong offset = buf1 - base;
Mike Frysinger054ea172012-01-20 09:07:21 +0000288 printf("%s at 0x%08lx (%#0*lx) != %s at 0x%08lx (%#0*lx)\n",
Simon Glass0628ab82013-02-24 17:33:15 +0000289 type, (ulong)(addr1 + offset), size, word1,
290 type, (ulong)(addr2 + offset), size, word2);
Mike Frysinger054ea172012-01-20 09:07:21 +0000291 rcode = 1;
292 break;
wdenk38635852002-08-27 05:55:31 +0000293 }
Mike Frysinger054ea172012-01-20 09:07:21 +0000294
Simon Glass0628ab82013-02-24 17:33:15 +0000295 buf1 += size;
296 buf2 += size;
Stefan Roeseeaadb442010-09-13 11:10:34 +0200297
298 /* reset watchdog from time to time */
Mike Frysingerfeb12a12012-01-20 09:07:22 +0000299 if ((ngood % (64 << 10)) == 0)
Stefan Roeseeaadb442010-09-13 11:10:34 +0200300 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000301 }
Simon Glass0628ab82013-02-24 17:33:15 +0000302 unmap_sysmem(buf1);
303 unmap_sysmem(buf2);
wdenk38635852002-08-27 05:55:31 +0000304
Mike Frysinger054ea172012-01-20 09:07:21 +0000305 printf("Total of %ld %s(s) were the same\n", ngood, type);
wdenk38635852002-08-27 05:55:31 +0000306 return rcode;
307}
308
Simon Glass09140112020-05-10 11:40:03 -0600309static int do_mem_cp(struct cmd_tbl *cmdtp, int flag, int argc,
310 char *const argv[])
wdenk38635852002-08-27 05:55:31 +0000311{
Fabio Estevamc2538422016-12-15 16:00:13 -0200312 ulong addr, dest, count;
Philippe Reynes787f10a2019-12-02 17:33:22 +0100313 void *src, *dst;
wdenk27b207f2003-07-24 23:38:38 +0000314 int size;
wdenk38635852002-08-27 05:55:31 +0000315
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200316 if (argc != 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000317 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000318
319 /* Check for size specification.
320 */
wdenk27b207f2003-07-24 23:38:38 +0000321 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
322 return 1;
wdenk38635852002-08-27 05:55:31 +0000323
324 addr = simple_strtoul(argv[1], NULL, 16);
325 addr += base_address;
326
327 dest = simple_strtoul(argv[2], NULL, 16);
328 dest += base_address;
329
330 count = simple_strtoul(argv[3], NULL, 16);
331
332 if (count == 0) {
333 puts ("Zero length ???\n");
334 return 1;
335 }
336
Philippe Reynes787f10a2019-12-02 17:33:22 +0100337 src = map_sysmem(addr, count * size);
338 dst = map_sysmem(dest, count * size);
339
Masahiro Yamadae856bdc2017-02-11 22:43:54 +0900340#ifdef CONFIG_MTD_NOR_FLASH
wdenk38635852002-08-27 05:55:31 +0000341 /* check if we are copying to Flash */
Philippe Reynes787f10a2019-12-02 17:33:22 +0100342 if (addr2info((ulong)dst)) {
wdenk38635852002-08-27 05:55:31 +0000343 int rc;
344
wdenk4b9206e2004-03-23 22:14:11 +0000345 puts ("Copy to Flash... ");
wdenk38635852002-08-27 05:55:31 +0000346
Philippe Reynes787f10a2019-12-02 17:33:22 +0100347 rc = flash_write((char *)src, (ulong)dst, count * size);
wdenk38635852002-08-27 05:55:31 +0000348 if (rc != 0) {
Simon Glass0ee482522019-12-28 10:44:40 -0700349 flash_perror(rc);
Philippe Reynes787f10a2019-12-02 17:33:22 +0100350 unmap_sysmem(src);
351 unmap_sysmem(dst);
wdenk38635852002-08-27 05:55:31 +0000352 return (1);
353 }
354 puts ("done\n");
Philippe Reynes787f10a2019-12-02 17:33:22 +0100355 unmap_sysmem(src);
356 unmap_sysmem(dst);
wdenk38635852002-08-27 05:55:31 +0000357 return 0;
358 }
359#endif
360
Philippe Reynes787f10a2019-12-02 17:33:22 +0100361 memcpy(dst, src, count * size);
Masahiro Yamadaa3a47492014-10-23 17:46:24 +0900362
Philippe Reynes787f10a2019-12-02 17:33:22 +0100363 unmap_sysmem(src);
364 unmap_sysmem(dst);
wdenk38635852002-08-27 05:55:31 +0000365 return 0;
366}
367
Simon Glass550a9e72020-07-28 19:41:14 -0600368#ifdef CONFIG_CMD_MEM_SEARCH
Simon Glassbdded202020-06-02 19:26:49 -0600369static int do_mem_search(struct cmd_tbl *cmdtp, int flag, int argc,
370 char *const argv[])
371{
372 ulong addr, length, bytes, offset;
373 u8 *ptr, *end, *buf;
374 bool quiet = false;
375 ulong last_pos; /* Offset of last match in 'size' units*/
376 ulong last_addr; /* Address of last displayed line */
377 int limit = 10;
Simon Glass550a9e72020-07-28 19:41:14 -0600378 int used_len;
Simon Glassbdded202020-06-02 19:26:49 -0600379 int count;
380 int size;
381 int i;
382
383 /* We use the last specified parameters, unless new ones are entered */
384 addr = dp_last_addr;
385 size = dp_last_size;
Simon Glass550a9e72020-07-28 19:41:14 -0600386 length = dp_last_ms_length;
Simon Glassbdded202020-06-02 19:26:49 -0600387
388 if (argc < 3)
389 return CMD_RET_USAGE;
390
Simon Glass550a9e72020-07-28 19:41:14 -0600391 if (!(flag & CMD_FLAG_REPEAT)) {
Simon Glassbdded202020-06-02 19:26:49 -0600392 /*
393 * Check for a size specification.
394 * Defaults to long if no or incorrect specification.
395 */
396 size = cmd_get_data_size(argv[0], 4);
Simon Glass7526dee2020-11-01 14:15:36 -0700397 if (size < 0 && size != CMD_DATA_SIZE_STR)
Simon Glassbdded202020-06-02 19:26:49 -0600398 return 1;
399
Simon Glass550a9e72020-07-28 19:41:14 -0600400 argc--;
401 argv++;
Simon Glassbdded202020-06-02 19:26:49 -0600402 while (argc && *argv[0] == '-') {
403 int ch = argv[0][1];
404
405 if (ch == 'q')
406 quiet = true;
407 else if (ch == 'l' && isxdigit(argv[0][2]))
408 limit = simple_strtoul(argv[0] + 2, NULL, 16);
409 else
410 return CMD_RET_USAGE;
Simon Glass550a9e72020-07-28 19:41:14 -0600411 argc--;
412 argv++;
Simon Glassbdded202020-06-02 19:26:49 -0600413 }
414
415 /* Address is specified since argc > 1 */
416 addr = simple_strtoul(argv[0], NULL, 16);
417 addr += base_address;
418
419 /* Length is the number of objects, not number of bytes */
420 length = simple_strtoul(argv[1], NULL, 16);
421
422 /* Read the bytes to search for */
423 end = search_buf + sizeof(search_buf);
424 for (i = 2, ptr = search_buf; i < argc && ptr < end; i++) {
Simon Glass550a9e72020-07-28 19:41:14 -0600425 if (MEM_SUPPORT_64BIT_DATA && size == 8) {
Simon Glassbdded202020-06-02 19:26:49 -0600426 u64 val = simple_strtoull(argv[i], NULL, 16);
427
428 *(u64 *)ptr = val;
429 } else if (size == -2) { /* string */
430 int len = min(strlen(argv[i]),
431 (size_t)(end - ptr));
432
433 memcpy(ptr, argv[i], len);
434 ptr += len;
435 continue;
436 } else {
437 u32 val = simple_strtoul(argv[i], NULL, 16);
438
439 switch (size) {
440 case 1:
441 *ptr = val;
442 break;
443 case 2:
444 *(u16 *)ptr = val;
445 break;
446 case 4:
447 *(u32 *)ptr = val;
448 break;
449 }
450 }
451 ptr += size;
452 }
453 search_len = ptr - search_buf;
454 }
455
456 /* Do the search */
457 if (size == -2)
458 size = 1;
459 bytes = size * length;
460 buf = map_sysmem(addr, bytes);
461 last_pos = 0;
462 last_addr = 0;
463 count = 0;
Simon Glass550a9e72020-07-28 19:41:14 -0600464 for (offset = 0;
465 offset < bytes && offset <= bytes - search_len && count < limit;
Simon Glassbdded202020-06-02 19:26:49 -0600466 offset += size) {
467 void *ptr = buf + offset;
468
469 if (!memcmp(ptr, search_buf, search_len)) {
470 uint align = (addr + offset) & 0xf;
471 ulong match = addr + offset;
472
473 if (!count || (last_addr & ~0xf) != (match & ~0xf)) {
474 if (!quiet) {
475 if (count)
476 printf("--\n");
477 print_buffer(match - align, ptr - align,
478 size,
479 ALIGN(search_len + align,
480 16) / size, 0);
481 }
482 last_addr = match;
483 last_pos = offset / size;
484 }
485 count++;
486 }
487 }
488 if (!quiet) {
489 printf("%d match%s", count, count == 1 ? "" : "es");
490 if (count == limit)
491 printf(" (repeat command to check for more)");
492 printf("\n");
493 }
494 env_set_hex("memmatches", count);
495 env_set_hex("memaddr", last_addr);
496 env_set_hex("mempos", last_pos);
497
498 unmap_sysmem(buf);
499
Simon Glass550a9e72020-07-28 19:41:14 -0600500 used_len = offset / size;
501 dp_last_addr = addr + used_len;
Simon Glassbdded202020-06-02 19:26:49 -0600502 dp_last_size = size;
Simon Glass550a9e72020-07-28 19:41:14 -0600503 dp_last_ms_length = length < used_len ? 0 : length - used_len;
Simon Glassbdded202020-06-02 19:26:49 -0600504
505 return count ? 0 : CMD_RET_FAILURE;
506}
507#endif
508
Simon Glass09140112020-05-10 11:40:03 -0600509static int do_mem_base(struct cmd_tbl *cmdtp, int flag, int argc,
510 char *const argv[])
wdenk38635852002-08-27 05:55:31 +0000511{
512 if (argc > 1) {
513 /* Set new base address.
514 */
515 base_address = simple_strtoul(argv[1], NULL, 16);
516 }
517 /* Print the current base address.
518 */
519 printf("Base Address: 0x%08lx\n", base_address);
520 return 0;
521}
522
Simon Glass09140112020-05-10 11:40:03 -0600523static int do_mem_loop(struct cmd_tbl *cmdtp, int flag, int argc,
524 char *const argv[])
wdenk38635852002-08-27 05:55:31 +0000525{
Simon Glass0628ab82013-02-24 17:33:15 +0000526 ulong addr, length, i, bytes;
wdenk27b207f2003-07-24 23:38:38 +0000527 int size;
Simon Glass46809762020-06-02 19:26:46 -0600528 volatile ulong *llp; /* 64-bit if SUPPORT_64BIT_DATA */
York Sun76698b42014-02-12 15:55:35 -0800529 volatile u32 *longp;
530 volatile u16 *shortp;
531 volatile u8 *cp;
Simon Glass0628ab82013-02-24 17:33:15 +0000532 const void *buf;
wdenk38635852002-08-27 05:55:31 +0000533
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200534 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000535 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +0000536
Robert P. J. Day85de63e2013-02-03 02:29:54 +0000537 /*
538 * Check for a size specification.
wdenk38635852002-08-27 05:55:31 +0000539 * Defaults to long if no or incorrect specification.
540 */
wdenk27b207f2003-07-24 23:38:38 +0000541 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
542 return 1;
wdenk38635852002-08-27 05:55:31 +0000543
544 /* Address is always specified.
545 */
546 addr = simple_strtoul(argv[1], NULL, 16);
547
548 /* Length is the number of objects, not number of bytes.
549 */
550 length = simple_strtoul(argv[2], NULL, 16);
551
Simon Glass0628ab82013-02-24 17:33:15 +0000552 bytes = size * length;
553 buf = map_sysmem(addr, bytes);
554
wdenk38635852002-08-27 05:55:31 +0000555 /* We want to optimize the loops to run as fast as possible.
556 * If we have only one object, just run infinite loops.
557 */
558 if (length == 1) {
Simon Glass46809762020-06-02 19:26:46 -0600559 if (SUPPORT_64BIT_DATA && size == 8) {
560 llp = (ulong *)buf;
York Sun4d1fd7f2014-02-26 17:03:19 -0800561 for (;;)
562 i = *llp;
563 }
wdenk38635852002-08-27 05:55:31 +0000564 if (size == 4) {
York Sun76698b42014-02-12 15:55:35 -0800565 longp = (u32 *)buf;
wdenk38635852002-08-27 05:55:31 +0000566 for (;;)
567 i = *longp;
568 }
569 if (size == 2) {
York Sun76698b42014-02-12 15:55:35 -0800570 shortp = (u16 *)buf;
wdenk38635852002-08-27 05:55:31 +0000571 for (;;)
572 i = *shortp;
573 }
York Sun76698b42014-02-12 15:55:35 -0800574 cp = (u8 *)buf;
wdenk38635852002-08-27 05:55:31 +0000575 for (;;)
576 i = *cp;
577 }
578
Simon Glass46809762020-06-02 19:26:46 -0600579 if (SUPPORT_64BIT_DATA && size == 8) {
York Sun4d1fd7f2014-02-26 17:03:19 -0800580 for (;;) {
Simon Glass46809762020-06-02 19:26:46 -0600581 llp = (ulong *)buf;
York Sun4d1fd7f2014-02-26 17:03:19 -0800582 i = length;
583 while (i-- > 0)
584 *llp++;
585 }
586 }
wdenk38635852002-08-27 05:55:31 +0000587 if (size == 4) {
588 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800589 longp = (u32 *)buf;
wdenk38635852002-08-27 05:55:31 +0000590 i = length;
591 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200592 *longp++;
wdenk38635852002-08-27 05:55:31 +0000593 }
594 }
595 if (size == 2) {
596 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800597 shortp = (u16 *)buf;
wdenk38635852002-08-27 05:55:31 +0000598 i = length;
599 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200600 *shortp++;
wdenk38635852002-08-27 05:55:31 +0000601 }
602 }
603 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800604 cp = (u8 *)buf;
wdenk38635852002-08-27 05:55:31 +0000605 i = length;
606 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200607 *cp++;
wdenk38635852002-08-27 05:55:31 +0000608 }
Simon Glass0628ab82013-02-24 17:33:15 +0000609 unmap_sysmem(buf);
Simon Glass92765f422013-06-11 11:14:35 -0700610
611 return 0;
wdenk38635852002-08-27 05:55:31 +0000612}
613
wdenk56523f12004-07-11 17:40:54 +0000614#ifdef CONFIG_LOOPW
Simon Glass09140112020-05-10 11:40:03 -0600615static int do_mem_loopw(struct cmd_tbl *cmdtp, int flag, int argc,
616 char *const argv[])
wdenk56523f12004-07-11 17:40:54 +0000617{
York Sun4d1fd7f2014-02-26 17:03:19 -0800618 ulong addr, length, i, bytes;
wdenk56523f12004-07-11 17:40:54 +0000619 int size;
Simon Glass46809762020-06-02 19:26:46 -0600620 volatile ulong *llp; /* 64-bit if SUPPORT_64BIT_DATA */
621 ulong data; /* 64-bit if SUPPORT_64BIT_DATA */
York Sun76698b42014-02-12 15:55:35 -0800622 volatile u32 *longp;
623 volatile u16 *shortp;
624 volatile u8 *cp;
Simon Glass0628ab82013-02-24 17:33:15 +0000625 void *buf;
wdenk81050922004-07-11 20:04:51 +0000626
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200627 if (argc < 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000628 return CMD_RET_USAGE;
wdenk56523f12004-07-11 17:40:54 +0000629
Robert P. J. Day85de63e2013-02-03 02:29:54 +0000630 /*
631 * Check for a size specification.
wdenk56523f12004-07-11 17:40:54 +0000632 * Defaults to long if no or incorrect specification.
633 */
634 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
635 return 1;
636
637 /* Address is always specified.
638 */
639 addr = simple_strtoul(argv[1], NULL, 16);
640
641 /* Length is the number of objects, not number of bytes.
642 */
643 length = simple_strtoul(argv[2], NULL, 16);
644
645 /* data to write */
Simon Glass46809762020-06-02 19:26:46 -0600646 if (SUPPORT_64BIT_DATA)
647 data = simple_strtoull(argv[3], NULL, 16);
648 else
649 data = simple_strtoul(argv[3], NULL, 16);
wdenk81050922004-07-11 20:04:51 +0000650
Simon Glass0628ab82013-02-24 17:33:15 +0000651 bytes = size * length;
652 buf = map_sysmem(addr, bytes);
653
wdenk56523f12004-07-11 17:40:54 +0000654 /* We want to optimize the loops to run as fast as possible.
655 * If we have only one object, just run infinite loops.
656 */
657 if (length == 1) {
Simon Glass46809762020-06-02 19:26:46 -0600658 if (SUPPORT_64BIT_DATA && size == 8) {
659 llp = (ulong *)buf;
York Sun4d1fd7f2014-02-26 17:03:19 -0800660 for (;;)
661 *llp = data;
662 }
wdenk56523f12004-07-11 17:40:54 +0000663 if (size == 4) {
York Sun76698b42014-02-12 15:55:35 -0800664 longp = (u32 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000665 for (;;)
666 *longp = data;
York Sun4d1fd7f2014-02-26 17:03:19 -0800667 }
wdenk56523f12004-07-11 17:40:54 +0000668 if (size == 2) {
York Sun76698b42014-02-12 15:55:35 -0800669 shortp = (u16 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000670 for (;;)
671 *shortp = data;
672 }
York Sun76698b42014-02-12 15:55:35 -0800673 cp = (u8 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000674 for (;;)
675 *cp = data;
676 }
677
Simon Glass46809762020-06-02 19:26:46 -0600678 if (SUPPORT_64BIT_DATA && size == 8) {
York Sun4d1fd7f2014-02-26 17:03:19 -0800679 for (;;) {
Simon Glass46809762020-06-02 19:26:46 -0600680 llp = (ulong *)buf;
York Sun4d1fd7f2014-02-26 17:03:19 -0800681 i = length;
682 while (i-- > 0)
683 *llp++ = data;
684 }
685 }
wdenk56523f12004-07-11 17:40:54 +0000686 if (size == 4) {
687 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800688 longp = (u32 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000689 i = length;
690 while (i-- > 0)
691 *longp++ = data;
692 }
693 }
694 if (size == 2) {
695 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800696 shortp = (u16 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000697 i = length;
698 while (i-- > 0)
699 *shortp++ = data;
700 }
701 }
702 for (;;) {
York Sun76698b42014-02-12 15:55:35 -0800703 cp = (u8 *)buf;
wdenk56523f12004-07-11 17:40:54 +0000704 i = length;
705 while (i-- > 0)
706 *cp++ = data;
707 }
708}
709#endif /* CONFIG_LOOPW */
710
Tom Rini68149e92013-03-12 10:07:19 -0400711#ifdef CONFIG_CMD_MEMTEST
Simon Glass5512d5b2013-02-28 17:47:14 +0000712static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
713 vu_long *dummy)
wdenk38635852002-08-27 05:55:31 +0000714{
Simon Glassc9638f52013-02-24 17:33:16 +0000715 vu_long *addr;
Simon Glassc9638f52013-02-24 17:33:16 +0000716 ulong errs = 0;
717 ulong val, readback;
718 int j;
Simon Glassc9638f52013-02-24 17:33:16 +0000719 vu_long offset;
720 vu_long test_offset;
721 vu_long pattern;
722 vu_long temp;
723 vu_long anti_pattern;
724 vu_long num_words;
wdenk38635852002-08-27 05:55:31 +0000725 static const ulong bitpattern[] = {
726 0x00000001, /* single bit */
727 0x00000003, /* two adjacent bits */
728 0x00000007, /* three adjacent bits */
729 0x0000000F, /* four adjacent bits */
730 0x00000005, /* two non-adjacent bits */
731 0x00000015, /* three non-adjacent bits */
732 0x00000055, /* four non-adjacent bits */
733 0xaaaaaaaa, /* alternating 1/0 */
734 };
wdenk38635852002-08-27 05:55:31 +0000735
Simon Glass5512d5b2013-02-28 17:47:14 +0000736 num_words = (end_addr - start_addr) / sizeof(vu_long);
Simon Glass8c86bbe2013-02-24 17:33:20 +0000737
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000738 /*
739 * Data line test: write a pattern to the first
740 * location, write the 1's complement to a 'parking'
741 * address (changes the state of the data bus so a
742 * floating bus doesn't give a false OK), and then
743 * read the value back. Note that we read it back
744 * into a variable because the next time we read it,
745 * it might be right (been there, tough to explain to
746 * the quality guys why it prints a failure when the
747 * "is" and "should be" are obviously the same in the
748 * error message).
749 *
750 * Rather than exhaustively testing, we test some
751 * patterns by shifting '1' bits through a field of
752 * '0's and '0' bits through a field of '1's (i.e.
753 * pattern and ~pattern).
754 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000755 addr = buf;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000756 for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) {
757 val = bitpattern[j];
758 for (; val != 0; val <<= 1) {
Simon Glass5512d5b2013-02-28 17:47:14 +0000759 *addr = val;
Simon Glassc9638f52013-02-24 17:33:16 +0000760 *dummy = ~val; /* clear the test data off the bus */
wdenk38635852002-08-27 05:55:31 +0000761 readback = *addr;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000762 if (readback != val) {
Simon Glassc9638f52013-02-24 17:33:16 +0000763 printf("FAILURE (data line): "
764 "expected %08lx, actual %08lx\n",
765 val, readback);
766 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000767 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000768 return -1;
wdenk38635852002-08-27 05:55:31 +0000769 }
770 *addr = ~val;
771 *dummy = val;
772 readback = *addr;
Simon Glassc9638f52013-02-24 17:33:16 +0000773 if (readback != ~val) {
774 printf("FAILURE (data line): "
775 "Is %08lx, should be %08lx\n",
776 readback, ~val);
777 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000778 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000779 return -1;
wdenk38635852002-08-27 05:55:31 +0000780 }
wdenk38635852002-08-27 05:55:31 +0000781 }
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000782 }
wdenk38635852002-08-27 05:55:31 +0000783
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000784 /*
785 * Based on code whose Original Author and Copyright
786 * information follows: Copyright (c) 1998 by Michael
787 * Barr. This software is placed into the public
788 * domain and may be used for any purpose. However,
789 * this notice must not be changed or removed and no
790 * warranty is either expressed or implied by its
791 * publication or distribution.
792 */
wdenk38635852002-08-27 05:55:31 +0000793
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000794 /*
795 * Address line test
wdenk38635852002-08-27 05:55:31 +0000796
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000797 * Description: Test the address bus wiring in a
798 * memory region by performing a walking
799 * 1's test on the relevant bits of the
800 * address and checking for aliasing.
801 * This test will find single-bit
802 * address failures such as stuck-high,
803 * stuck-low, and shorted pins. The base
804 * address and size of the region are
805 * selected by the caller.
wdenk38635852002-08-27 05:55:31 +0000806
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000807 * Notes: For best results, the selected base
808 * address should have enough LSB 0's to
809 * guarantee single address bit changes.
810 * For example, to test a 64-Kbyte
811 * region, select a base address on a
812 * 64-Kbyte boundary. Also, select the
813 * region size as a power-of-two if at
814 * all possible.
815 *
816 * Returns: 0 if the test succeeds, 1 if the test fails.
817 */
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000818 pattern = (vu_long) 0xaaaaaaaa;
819 anti_pattern = (vu_long) 0x55555555;
wdenk38635852002-08-27 05:55:31 +0000820
Simon Glass5512d5b2013-02-28 17:47:14 +0000821 debug("%s:%d: length = 0x%.8lx\n", __func__, __LINE__, num_words);
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000822 /*
823 * Write the default pattern at each of the
824 * power-of-two offsets.
825 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000826 for (offset = 1; offset < num_words; offset <<= 1)
827 addr[offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000828
829 /*
830 * Check for address bits stuck high.
831 */
832 test_offset = 0;
Simon Glass5512d5b2013-02-28 17:47:14 +0000833 addr[test_offset] = anti_pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000834
Simon Glass5512d5b2013-02-28 17:47:14 +0000835 for (offset = 1; offset < num_words; offset <<= 1) {
836 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000837 if (temp != pattern) {
Simon Glassc9638f52013-02-24 17:33:16 +0000838 printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
wdenk38635852002-08-27 05:55:31 +0000839 " expected 0x%.8lx, actual 0x%.8lx\n",
David Feng102c0512014-02-12 16:10:08 +0800840 start_addr + offset*sizeof(vu_long),
841 pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400842 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000843 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000844 return -1;
wdenk38635852002-08-27 05:55:31 +0000845 }
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000846 }
Simon Glass5512d5b2013-02-28 17:47:14 +0000847 addr[test_offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000848 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000849
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000850 /*
851 * Check for addr bits stuck low or shorted.
852 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000853 for (test_offset = 1; test_offset < num_words; test_offset <<= 1) {
854 addr[test_offset] = anti_pattern;
wdenk38635852002-08-27 05:55:31 +0000855
Simon Glass5512d5b2013-02-28 17:47:14 +0000856 for (offset = 1; offset < num_words; offset <<= 1) {
857 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000858 if ((temp != pattern) && (offset != test_offset)) {
859 printf("\nFAILURE: Address bit stuck low or"
860 " shorted @ 0x%.8lx: expected 0x%.8lx,"
861 " actual 0x%.8lx\n",
David Feng102c0512014-02-12 16:10:08 +0800862 start_addr + offset*sizeof(vu_long),
863 pattern, temp);
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000864 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000865 if (ctrlc())
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000866 return -1;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000867 }
wdenk38635852002-08-27 05:55:31 +0000868 }
Simon Glass5512d5b2013-02-28 17:47:14 +0000869 addr[test_offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000870 }
wdenk38635852002-08-27 05:55:31 +0000871
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000872 /*
873 * Description: Test the integrity of a physical
874 * memory device by performing an
875 * increment/decrement test over the
876 * entire region. In the process every
877 * storage bit in the device is tested
878 * as a zero and a one. The base address
879 * and the size of the region are
880 * selected by the caller.
881 *
882 * Returns: 0 if the test succeeds, 1 if the test fails.
883 */
Simon Glass5512d5b2013-02-28 17:47:14 +0000884 num_words++;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000885
886 /*
887 * Fill memory with a known pattern.
888 */
889 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
890 WATCHDOG_RESET();
Simon Glass5512d5b2013-02-28 17:47:14 +0000891 addr[offset] = pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000892 }
893
894 /*
895 * Check each location and invert it for the second pass.
896 */
897 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
898 WATCHDOG_RESET();
Simon Glass5512d5b2013-02-28 17:47:14 +0000899 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000900 if (temp != pattern) {
Simon Glassc9638f52013-02-24 17:33:16 +0000901 printf("\nFAILURE (read/write) @ 0x%.8lx:"
wdenk38635852002-08-27 05:55:31 +0000902 " expected 0x%.8lx, actual 0x%.8lx)\n",
David Feng102c0512014-02-12 16:10:08 +0800903 start_addr + offset*sizeof(vu_long),
904 pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400905 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000906 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000907 return -1;
wdenk38635852002-08-27 05:55:31 +0000908 }
909
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000910 anti_pattern = ~pattern;
Simon Glass5512d5b2013-02-28 17:47:14 +0000911 addr[offset] = anti_pattern;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000912 }
913
914 /*
915 * Check each location for the inverted pattern and zero it.
916 */
917 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
918 WATCHDOG_RESET();
919 anti_pattern = ~pattern;
Simon Glass5512d5b2013-02-28 17:47:14 +0000920 temp = addr[offset];
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000921 if (temp != anti_pattern) {
Simon Glassc9638f52013-02-24 17:33:16 +0000922 printf("\nFAILURE (read/write): @ 0x%.8lx:"
wdenk38635852002-08-27 05:55:31 +0000923 " expected 0x%.8lx, actual 0x%.8lx)\n",
David Feng102c0512014-02-12 16:10:08 +0800924 start_addr + offset*sizeof(vu_long),
925 anti_pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400926 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +0000927 if (ctrlc())
Simon Glass51209b12013-02-24 17:33:17 +0000928 return -1;
wdenk38635852002-08-27 05:55:31 +0000929 }
Simon Glass5512d5b2013-02-28 17:47:14 +0000930 addr[offset] = 0;
Simon Glass7ecbd4d2013-02-24 17:33:18 +0000931 }
Simon Glass51209b12013-02-24 17:33:17 +0000932
Rasmus Villemoesfea67302016-01-07 11:36:04 +0100933 return errs;
Simon Glassc9638f52013-02-24 17:33:16 +0000934}
wdenk38635852002-08-27 05:55:31 +0000935
Stefan Roese8e434cb2020-03-05 07:21:32 +0100936static int compare_regions(volatile unsigned long *bufa,
937 volatile unsigned long *bufb, size_t count)
938{
939 volatile unsigned long *p1 = bufa;
940 volatile unsigned long *p2 = bufb;
941 int errs = 0;
942 size_t i;
943
944 for (i = 0; i < count; i++, p1++, p2++) {
945 if (*p1 != *p2) {
946 printf("FAILURE: 0x%08lx != 0x%08lx (delta=0x%08lx -> bit %ld) at offset 0x%08lx\n",
947 (unsigned long)*p1, (unsigned long)*p2,
948 *p1 ^ *p2, __ffs(*p1 ^ *p2),
949 (unsigned long)(i * sizeof(unsigned long)));
950 errs++;
951 }
952 }
953
954 return errs;
955}
956
957static ulong test_bitflip_comparison(volatile unsigned long *bufa,
958 volatile unsigned long *bufb, size_t count)
959{
960 volatile unsigned long *p1 = bufa;
961 volatile unsigned long *p2 = bufb;
962 unsigned int j, k;
963 unsigned long q;
964 size_t i;
965 int max;
966 int errs = 0;
967
968 max = sizeof(unsigned long) * 8;
969 for (k = 0; k < max; k++) {
970 q = 0x00000001L << k;
971 for (j = 0; j < 8; j++) {
972 WATCHDOG_RESET();
973 q = ~q;
974 p1 = (volatile unsigned long *)bufa;
975 p2 = (volatile unsigned long *)bufb;
976 for (i = 0; i < count; i++)
977 *p1++ = *p2++ = (i % 2) == 0 ? q : ~q;
978
979 errs += compare_regions(bufa, bufb, count);
980 }
981
982 if (ctrlc())
983 return -1UL;
984 }
985
986 return errs;
987}
988
Ralph Siemsen9989fb12020-09-09 12:10:00 -0400989static ulong mem_test_bitflip(vu_long *buf, ulong start, ulong end)
990{
991 /*
992 * Split the specified range into two halves.
993 * Note that mtest range is inclusive of start,end.
994 * Bitflip test instead uses a count (of 32-bit words).
995 */
996 ulong half_size = (end - start + 1) / 2 / sizeof(unsigned long);
997
998 return test_bitflip_comparison(buf, buf + half_size, half_size);
999}
1000
Simon Glass5512d5b2013-02-28 17:47:14 +00001001static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
1002 vu_long pattern, int iteration)
Simon Glassc9638f52013-02-24 17:33:16 +00001003{
Simon Glass5512d5b2013-02-28 17:47:14 +00001004 vu_long *end;
Simon Glassc9638f52013-02-24 17:33:16 +00001005 vu_long *addr;
Simon Glassc9638f52013-02-24 17:33:16 +00001006 ulong errs = 0;
Simon Glass5512d5b2013-02-28 17:47:14 +00001007 ulong incr, length;
Simon Glassc9638f52013-02-24 17:33:16 +00001008 ulong val, readback;
1009
Simon Glass51209b12013-02-24 17:33:17 +00001010 /* Alternate the pattern */
wdenk38635852002-08-27 05:55:31 +00001011 incr = 1;
Simon Glass51209b12013-02-24 17:33:17 +00001012 if (iteration & 1) {
1013 incr = -incr;
1014 /*
1015 * Flip the pattern each time to make lots of zeros and
1016 * then, the next time, lots of ones. We decrement
1017 * the "negative" patterns and increment the "positive"
1018 * patterns to preserve this feature.
1019 */
1020 if (pattern & 0x80000000)
1021 pattern = -pattern; /* complement & increment */
1022 else
1023 pattern = ~pattern;
1024 }
Simon Glass5512d5b2013-02-28 17:47:14 +00001025 length = (end_addr - start_addr) / sizeof(ulong);
1026 end = buf + length;
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001027 printf("\rPattern %08lX Writing..."
1028 "%12s"
1029 "\b\b\b\b\b\b\b\b\b\b",
1030 pattern, "");
wdenk38635852002-08-27 05:55:31 +00001031
Simon Glass5512d5b2013-02-28 17:47:14 +00001032 for (addr = buf, val = pattern; addr < end; addr++) {
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001033 WATCHDOG_RESET();
1034 *addr = val;
1035 val += incr;
1036 }
wdenk38635852002-08-27 05:55:31 +00001037
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001038 puts("Reading...");
wdenk38635852002-08-27 05:55:31 +00001039
Simon Glass5512d5b2013-02-28 17:47:14 +00001040 for (addr = buf, val = pattern; addr < end; addr++) {
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001041 WATCHDOG_RESET();
1042 readback = *addr;
1043 if (readback != val) {
Simon Glass5512d5b2013-02-28 17:47:14 +00001044 ulong offset = addr - buf;
1045
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001046 printf("\nMem error @ 0x%08X: "
1047 "found %08lX, expected %08lX\n",
David Feng102c0512014-02-12 16:10:08 +08001048 (uint)(uintptr_t)(start_addr + offset*sizeof(vu_long)),
Simon Glass5512d5b2013-02-28 17:47:14 +00001049 readback, val);
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001050 errs++;
Simon Glassc44d4382013-02-24 17:33:19 +00001051 if (ctrlc())
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001052 return -1;
wdenk38635852002-08-27 05:55:31 +00001053 }
Simon Glass7ecbd4d2013-02-24 17:33:18 +00001054 val += incr;
1055 }
wdenk38635852002-08-27 05:55:31 +00001056
Rasmus Villemoesfea67302016-01-07 11:36:04 +01001057 return errs;
Simon Glassc9638f52013-02-24 17:33:16 +00001058}
1059
1060/*
1061 * Perform a memory test. A more complete alternative test can be
1062 * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
1063 * interrupted by ctrl-c or by a failure of one of the sub-tests.
1064 */
Simon Glass09140112020-05-10 11:40:03 -06001065static int do_mem_mtest(struct cmd_tbl *cmdtp, int flag, int argc,
1066 char *const argv[])
Simon Glassc9638f52013-02-24 17:33:16 +00001067{
Simon Glass8c86bbe2013-02-24 17:33:20 +00001068 ulong start, end;
Michal Simeke519f032020-05-04 13:54:40 +02001069 vu_long scratch_space;
1070 vu_long *buf, *dummy = &scratch_space;
Tom Riniadcc5702015-04-07 09:38:54 -04001071 ulong iteration_limit = 0;
Stefan Roesea8c708e2020-03-05 07:21:29 +01001072 ulong count = 0;
Simon Glass51209b12013-02-24 17:33:17 +00001073 ulong errs = 0; /* number of errors, or -1 if interrupted */
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001074 ulong pattern = 0;
Simon Glass51209b12013-02-24 17:33:17 +00001075 int iteration;
Simon Glassc9638f52013-02-24 17:33:16 +00001076
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001077 start = CONFIG_SYS_MEMTEST_START;
1078 end = CONFIG_SYS_MEMTEST_END;
1079
Simon Glassc9638f52013-02-24 17:33:16 +00001080 if (argc > 1)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001081 if (strict_strtoul(argv[1], 16, &start) < 0)
1082 return CMD_RET_USAGE;
Simon Glassc9638f52013-02-24 17:33:16 +00001083
1084 if (argc > 2)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001085 if (strict_strtoul(argv[2], 16, &end) < 0)
1086 return CMD_RET_USAGE;
Simon Glassc9638f52013-02-24 17:33:16 +00001087
1088 if (argc > 3)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001089 if (strict_strtoul(argv[3], 16, &pattern) < 0)
1090 return CMD_RET_USAGE;
Simon Glassc9638f52013-02-24 17:33:16 +00001091
1092 if (argc > 4)
Pavel Macheke37f1eb2015-04-01 13:50:41 +02001093 if (strict_strtoul(argv[4], 16, &iteration_limit) < 0)
1094 return CMD_RET_USAGE;
1095
1096 if (end < start) {
1097 printf("Refusing to do empty test\n");
1098 return -1;
1099 }
Simon Glassc9638f52013-02-24 17:33:16 +00001100
Michal Simekdfe461d2016-02-24 08:36:02 +01001101 printf("Testing %08lx ... %08lx:\n", start, end);
Simon Glass8c86bbe2013-02-24 17:33:20 +00001102 debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__,
1103 start, end);
Simon Glass51209b12013-02-24 17:33:17 +00001104
Simon Glass5512d5b2013-02-28 17:47:14 +00001105 buf = map_sysmem(start, end - start);
Simon Glass51209b12013-02-24 17:33:17 +00001106 for (iteration = 0;
1107 !iteration_limit || iteration < iteration_limit;
1108 iteration++) {
1109 if (ctrlc()) {
Simon Glass51209b12013-02-24 17:33:17 +00001110 errs = -1UL;
1111 break;
1112 }
1113
1114 printf("Iteration: %6d\r", iteration + 1);
1115 debug("\n");
Stefan Roesef14bfa72020-03-05 07:21:31 +01001116 if (IS_ENABLED(CONFIG_SYS_ALT_MEMTEST)) {
Simon Glass5512d5b2013-02-28 17:47:14 +00001117 errs = mem_test_alt(buf, start, end, dummy);
Stefan Roese8e434cb2020-03-05 07:21:32 +01001118 if (errs == -1UL)
1119 break;
Ralph Siemsen9989fb12020-09-09 12:10:00 -04001120 if (IS_ENABLED(CONFIG_SYS_ALT_MEMTEST_BITFLIP)) {
1121 count += errs;
1122 errs = mem_test_bitflip(buf, start, end);
1123 }
Simon Glass5512d5b2013-02-28 17:47:14 +00001124 } else {
1125 errs = mem_test_quick(buf, start, end, pattern,
1126 iteration);
1127 }
1128 if (errs == -1UL)
1129 break;
Stefan Roesea8c708e2020-03-05 07:21:29 +01001130 count += errs;
Simon Glass5512d5b2013-02-28 17:47:14 +00001131 }
1132
Stefan Roese54de2442020-03-05 07:21:30 +01001133 unmap_sysmem((void *)buf);
Simon Glass51209b12013-02-24 17:33:17 +00001134
1135 if (errs == -1UL) {
Simon Glassc44d4382013-02-24 17:33:19 +00001136 /* Memory test was aborted - write a newline to finish off */
1137 putc('\n');
Simon Glass51209b12013-02-24 17:33:17 +00001138 }
Stefan Roesea8c708e2020-03-05 07:21:29 +01001139 printf("Tested %d iteration(s) with %lu errors.\n", iteration, count);
Simon Glassc9638f52013-02-24 17:33:16 +00001140
Stefan Roesea8c708e2020-03-05 07:21:29 +01001141 return errs != 0;
wdenk38635852002-08-27 05:55:31 +00001142}
Wolfgang Denka2681702013-03-08 10:51:32 +00001143#endif /* CONFIG_CMD_MEMTEST */
wdenk38635852002-08-27 05:55:31 +00001144
1145/* Modify memory.
1146 *
1147 * Syntax:
York Sun4d1fd7f2014-02-26 17:03:19 -08001148 * mm{.b, .w, .l, .q} {addr}
wdenk38635852002-08-27 05:55:31 +00001149 */
1150static int
Simon Glass09140112020-05-10 11:40:03 -06001151mod_mem(struct cmd_tbl *cmdtp, int incrflag, int flag, int argc,
1152 char *const argv[])
wdenk38635852002-08-27 05:55:31 +00001153{
York Sun4d1fd7f2014-02-26 17:03:19 -08001154 ulong addr;
Simon Glass46809762020-06-02 19:26:46 -06001155 ulong i; /* 64-bit if SUPPORT_64BIT_DATA */
wdenk27b207f2003-07-24 23:38:38 +00001156 int nbytes, size;
Simon Glass0628ab82013-02-24 17:33:15 +00001157 void *ptr = NULL;
wdenk38635852002-08-27 05:55:31 +00001158
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001159 if (argc != 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001160 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +00001161
Simon Glassb26440f2014-04-10 20:01:31 -06001162 bootretry_reset_cmd_timeout(); /* got a good command to get here */
wdenk38635852002-08-27 05:55:31 +00001163 /* We use the last specified parameters, unless new ones are
1164 * entered.
1165 */
1166 addr = mm_last_addr;
1167 size = mm_last_size;
1168
1169 if ((flag & CMD_FLAG_REPEAT) == 0) {
1170 /* New command specified. Check for a size specification.
1171 * Defaults to long if no or incorrect specification.
1172 */
wdenk27b207f2003-07-24 23:38:38 +00001173 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
1174 return 1;
wdenk38635852002-08-27 05:55:31 +00001175
1176 /* Address is specified since argc > 1
1177 */
1178 addr = simple_strtoul(argv[1], NULL, 16);
1179 addr += base_address;
1180 }
1181
1182 /* Print the address, followed by value. Then accept input for
1183 * the next value. A non-converted value exits.
1184 */
1185 do {
Simon Glass0628ab82013-02-24 17:33:15 +00001186 ptr = map_sysmem(addr, size);
wdenk38635852002-08-27 05:55:31 +00001187 printf("%08lx:", addr);
1188 if (size == 4)
York Sun76698b42014-02-12 15:55:35 -08001189 printf(" %08x", *((u32 *)ptr));
Simon Glass46809762020-06-02 19:26:46 -06001190 else if (SUPPORT_64BIT_DATA && size == 8)
1191 printf(" %0lx", *((ulong *)ptr));
wdenk38635852002-08-27 05:55:31 +00001192 else if (size == 2)
York Sun76698b42014-02-12 15:55:35 -08001193 printf(" %04x", *((u16 *)ptr));
wdenk38635852002-08-27 05:55:31 +00001194 else
York Sun76698b42014-02-12 15:55:35 -08001195 printf(" %02x", *((u8 *)ptr));
wdenk38635852002-08-27 05:55:31 +00001196
Simon Glasse1bf8242014-04-10 20:01:27 -06001197 nbytes = cli_readline(" ? ");
wdenk38635852002-08-27 05:55:31 +00001198 if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
1199 /* <CR> pressed as only input, don't modify current
1200 * location and move to next. "-" pressed will go back.
1201 */
1202 if (incrflag)
1203 addr += nbytes ? -size : size;
1204 nbytes = 1;
Simon Glassb26440f2014-04-10 20:01:31 -06001205 /* good enough to not time out */
1206 bootretry_reset_cmd_timeout();
wdenk38635852002-08-27 05:55:31 +00001207 }
1208#ifdef CONFIG_BOOT_RETRY_TIME
1209 else if (nbytes == -2) {
1210 break; /* timed out, exit the command */
1211 }
1212#endif
1213 else {
1214 char *endp;
Simon Glass46809762020-06-02 19:26:46 -06001215 if (SUPPORT_64BIT_DATA)
1216 i = simple_strtoull(console_buffer, &endp, 16);
1217 else
1218 i = simple_strtoul(console_buffer, &endp, 16);
wdenk38635852002-08-27 05:55:31 +00001219 nbytes = endp - console_buffer;
1220 if (nbytes) {
wdenk38635852002-08-27 05:55:31 +00001221 /* good enough to not time out
1222 */
Simon Glassb26440f2014-04-10 20:01:31 -06001223 bootretry_reset_cmd_timeout();
wdenk38635852002-08-27 05:55:31 +00001224 if (size == 4)
York Sun76698b42014-02-12 15:55:35 -08001225 *((u32 *)ptr) = i;
Simon Glass46809762020-06-02 19:26:46 -06001226 else if (SUPPORT_64BIT_DATA && size == 8)
1227 *((ulong *)ptr) = i;
wdenk38635852002-08-27 05:55:31 +00001228 else if (size == 2)
York Sun76698b42014-02-12 15:55:35 -08001229 *((u16 *)ptr) = i;
wdenk38635852002-08-27 05:55:31 +00001230 else
York Sun76698b42014-02-12 15:55:35 -08001231 *((u8 *)ptr) = i;
wdenk38635852002-08-27 05:55:31 +00001232 if (incrflag)
1233 addr += size;
1234 }
1235 }
1236 } while (nbytes);
Simon Glass0628ab82013-02-24 17:33:15 +00001237 if (ptr)
1238 unmap_sysmem(ptr);
wdenk38635852002-08-27 05:55:31 +00001239
1240 mm_last_addr = addr;
1241 mm_last_size = size;
1242 return 0;
1243}
1244
Mike Frysinger710b9932010-12-21 14:19:51 -05001245#ifdef CONFIG_CMD_CRC32
1246
Simon Glass09140112020-05-10 11:40:03 -06001247static int do_mem_crc(struct cmd_tbl *cmdtp, int flag, int argc,
1248 char *const argv[])
wdenk38635852002-08-27 05:55:31 +00001249{
Simon Glassd20a40d2013-02-24 20:30:22 +00001250 int flags = 0;
1251 int ac;
1252 char * const *av;
wdenk38635852002-08-27 05:55:31 +00001253
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001254 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001255 return CMD_RET_USAGE;
wdenk38635852002-08-27 05:55:31 +00001256
wdenkc26e4542004-04-18 10:13:26 +00001257 av = argv + 1;
1258 ac = argc - 1;
Daniel Thompson221a9492017-05-19 17:26:58 +01001259#ifdef CONFIG_CRC32_VERIFY
wdenkc26e4542004-04-18 10:13:26 +00001260 if (strcmp(*av, "-v") == 0) {
Joe Hershbergera69bdba2015-05-05 12:23:53 -05001261 flags |= HASH_FLAG_VERIFY | HASH_FLAG_ENV;
wdenkc26e4542004-04-18 10:13:26 +00001262 av++;
1263 ac--;
wdenkc26e4542004-04-18 10:13:26 +00001264 }
Simon Glassd20a40d2013-02-24 20:30:22 +00001265#endif
wdenkc26e4542004-04-18 10:13:26 +00001266
Simon Glassd20a40d2013-02-24 20:30:22 +00001267 return hash_command("crc32", flags, cmdtp, flag, ac, av);
wdenkc26e4542004-04-18 10:13:26 +00001268}
wdenkc26e4542004-04-18 10:13:26 +00001269
Mike Frysinger710b9932010-12-21 14:19:51 -05001270#endif
1271
Jean-Jacques Hiblot803e1a32019-07-02 14:23:26 +02001272#ifdef CONFIG_CMD_RANDOM
Simon Glass09140112020-05-10 11:40:03 -06001273static int do_random(struct cmd_tbl *cmdtp, int flag, int argc,
1274 char *const argv[])
Jean-Jacques Hiblot803e1a32019-07-02 14:23:26 +02001275{
1276 unsigned long addr, len;
1277 unsigned long seed; // NOT INITIALIZED ON PURPOSE
1278 unsigned int *buf, *start;
1279 unsigned char *buf8;
1280 unsigned int i;
1281
Eugeniy Paltsev5f2c4e02020-03-20 19:38:17 +03001282 if (argc < 3 || argc > 4)
1283 return CMD_RET_USAGE;
Jean-Jacques Hiblot803e1a32019-07-02 14:23:26 +02001284
1285 len = simple_strtoul(argv[2], NULL, 16);
1286 addr = simple_strtoul(argv[1], NULL, 16);
1287
1288 if (argc == 4) {
1289 seed = simple_strtoul(argv[3], NULL, 16);
1290 if (seed == 0) {
1291 printf("The seed cannot be 0. Using 0xDEADBEEF.\n");
1292 seed = 0xDEADBEEF;
1293 }
1294 } else {
1295 seed = get_timer(0) ^ rand();
1296 }
1297
1298 srand(seed);
1299 start = map_sysmem(addr, len);
1300 buf = start;
1301 for (i = 0; i < (len / 4); i++)
1302 *buf++ = rand();
1303
1304 buf8 = (unsigned char *)buf;
1305 for (i = 0; i < (len % 4); i++)
1306 *buf8++ = rand() & 0xFF;
1307
1308 unmap_sysmem(start);
1309 printf("%lu bytes filled with random data\n", len);
Eugeniy Paltsev5f2c4e02020-03-20 19:38:17 +03001310
1311 return CMD_RET_SUCCESS;
Jean-Jacques Hiblot803e1a32019-07-02 14:23:26 +02001312}
1313#endif
1314
wdenk8bde7f72003-06-27 21:31:46 +00001315/**************************************************/
wdenk0d498392003-07-01 21:06:45 +00001316U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001317 md, 3, 1, do_mem_md,
Peter Tyser2fb26042009-01-27 18:03:12 -06001318 "memory display",
Simon Glass76be8f72020-06-02 19:26:45 -06001319 "[.b, .w, .l" HELP_Q "] address [# of objects]"
wdenk8bde7f72003-06-27 21:31:46 +00001320);
1321
1322
wdenk0d498392003-07-01 21:06:45 +00001323U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001324 mm, 2, 1, do_mem_mm,
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001325 "memory modify (auto-incrementing address)",
Simon Glass76be8f72020-06-02 19:26:45 -06001326 "[.b, .w, .l" HELP_Q "] address"
wdenk8bde7f72003-06-27 21:31:46 +00001327);
1328
1329
wdenk0d498392003-07-01 21:06:45 +00001330U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001331 nm, 2, 1, do_mem_nm,
Peter Tyser2fb26042009-01-27 18:03:12 -06001332 "memory modify (constant address)",
Simon Glass76be8f72020-06-02 19:26:45 -06001333 "[.b, .w, .l" HELP_Q "] address"
wdenk8bde7f72003-06-27 21:31:46 +00001334);
1335
wdenk0d498392003-07-01 21:06:45 +00001336U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001337 mw, 4, 1, do_mem_mw,
Peter Tyser2fb26042009-01-27 18:03:12 -06001338 "memory write (fill)",
Simon Glass76be8f72020-06-02 19:26:45 -06001339 "[.b, .w, .l" HELP_Q "] address value [count]"
wdenk8bde7f72003-06-27 21:31:46 +00001340);
1341
wdenk0d498392003-07-01 21:06:45 +00001342U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001343 cp, 4, 1, do_mem_cp,
Peter Tyser2fb26042009-01-27 18:03:12 -06001344 "memory copy",
Simon Glass76be8f72020-06-02 19:26:45 -06001345 "[.b, .w, .l" HELP_Q "] source target count"
wdenk8bde7f72003-06-27 21:31:46 +00001346);
1347
wdenk0d498392003-07-01 21:06:45 +00001348U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001349 cmp, 4, 1, do_mem_cmp,
Peter Tyser2fb26042009-01-27 18:03:12 -06001350 "memory compare",
Simon Glass76be8f72020-06-02 19:26:45 -06001351 "[.b, .w, .l" HELP_Q "] addr1 addr2 count"
wdenk8bde7f72003-06-27 21:31:46 +00001352);
1353
Simon Glass550a9e72020-07-28 19:41:14 -06001354#ifdef CONFIG_CMD_MEM_SEARCH
Simon Glassbdded202020-06-02 19:26:49 -06001355/**************************************************/
1356U_BOOT_CMD(
1357 ms, 255, 1, do_mem_search,
1358 "memory search",
1359 "[.b, .w, .l" HELP_Q ", .s] [-q | -<n>] address #-of-objects <value>..."
Simon Glass550a9e72020-07-28 19:41:14 -06001360 " -q = quiet, -l<val> = match limit"
Simon Glassbdded202020-06-02 19:26:49 -06001361);
1362#endif
1363
Mike Frysinger710b9932010-12-21 14:19:51 -05001364#ifdef CONFIG_CMD_CRC32
1365
Daniel Thompson221a9492017-05-19 17:26:58 +01001366#ifndef CONFIG_CRC32_VERIFY
wdenkc26e4542004-04-18 10:13:26 +00001367
wdenk0d498392003-07-01 21:06:45 +00001368U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001369 crc32, 4, 1, do_mem_crc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001370 "checksum calculation",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001371 "address count [addr]\n - compute CRC32 checksum [save at addr]"
wdenk8bde7f72003-06-27 21:31:46 +00001372);
1373
Daniel Thompson221a9492017-05-19 17:26:58 +01001374#else /* CONFIG_CRC32_VERIFY */
wdenkc26e4542004-04-18 10:13:26 +00001375
1376U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001377 crc32, 5, 1, do_mem_crc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001378 "checksum calculation",
wdenkc26e4542004-04-18 10:13:26 +00001379 "address count [addr]\n - compute CRC32 checksum [save at addr]\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001380 "-v address count crc\n - verify crc of memory area"
wdenkc26e4542004-04-18 10:13:26 +00001381);
1382
Daniel Thompson221a9492017-05-19 17:26:58 +01001383#endif /* CONFIG_CRC32_VERIFY */
wdenkc26e4542004-04-18 10:13:26 +00001384
Mike Frysinger710b9932010-12-21 14:19:51 -05001385#endif
1386
Simon Glass15a33e42012-11-30 13:01:20 +00001387#ifdef CONFIG_CMD_MEMINFO
Simon Glass09140112020-05-10 11:40:03 -06001388static int do_mem_info(struct cmd_tbl *cmdtp, int flag, int argc,
1389 char *const argv[])
Simon Glass15a33e42012-11-30 13:01:20 +00001390{
Simon Glass428a6a12019-11-14 12:57:44 -07001391 puts("DRAM: ");
1392 print_size(gd->ram_size, "\n");
Simon Glass15a33e42012-11-30 13:01:20 +00001393
1394 return 0;
1395}
1396#endif
1397
wdenk0d498392003-07-01 21:06:45 +00001398U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001399 base, 2, 1, do_mem_base,
Peter Tyser2fb26042009-01-27 18:03:12 -06001400 "print or set address offset",
wdenk8bde7f72003-06-27 21:31:46 +00001401 "\n - print address offset for memory commands\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001402 "base off\n - set address offset for memory commands to 'off'"
wdenk8bde7f72003-06-27 21:31:46 +00001403);
1404
wdenk0d498392003-07-01 21:06:45 +00001405U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001406 loop, 3, 1, do_mem_loop,
Peter Tyser2fb26042009-01-27 18:03:12 -06001407 "infinite loop on address range",
Simon Glass76be8f72020-06-02 19:26:45 -06001408 "[.b, .w, .l" HELP_Q "] address number_of_objects"
wdenk8bde7f72003-06-27 21:31:46 +00001409);
1410
wdenk56523f12004-07-11 17:40:54 +00001411#ifdef CONFIG_LOOPW
1412U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001413 loopw, 4, 1, do_mem_loopw,
Peter Tyser2fb26042009-01-27 18:03:12 -06001414 "infinite write loop on address range",
Simon Glass76be8f72020-06-02 19:26:45 -06001415 "[.b, .w, .l" HELP_Q "] address number_of_objects data_to_write"
wdenk56523f12004-07-11 17:40:54 +00001416);
1417#endif /* CONFIG_LOOPW */
1418
Wolfgang Denka2681702013-03-08 10:51:32 +00001419#ifdef CONFIG_CMD_MEMTEST
wdenk0d498392003-07-01 21:06:45 +00001420U_BOOT_CMD(
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +01001421 mtest, 5, 1, do_mem_mtest,
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001422 "simple RAM read/write test",
1423 "[start [end [pattern [iterations]]]]"
wdenk8bde7f72003-06-27 21:31:46 +00001424);
Wolfgang Denka2681702013-03-08 10:51:32 +00001425#endif /* CONFIG_CMD_MEMTEST */
wdenk8bde7f72003-06-27 21:31:46 +00001426
Joel Johnson72732312020-01-29 09:17:18 -07001427#ifdef CONFIG_CMD_MX_CYCLIC
stroese4aaf29b2004-12-16 17:42:39 +00001428U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001429 mdc, 4, 1, do_mem_mdc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001430 "memory display cyclic",
Simon Glass76be8f72020-06-02 19:26:45 -06001431 "[.b, .w, .l" HELP_Q "] address count delay(ms)"
stroese4aaf29b2004-12-16 17:42:39 +00001432);
1433
1434U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001435 mwc, 4, 1, do_mem_mwc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001436 "memory write cyclic",
Simon Glass76be8f72020-06-02 19:26:45 -06001437 "[.b, .w, .l" HELP_Q "] address value delay(ms)"
stroese4aaf29b2004-12-16 17:42:39 +00001438);
Joel Johnson72732312020-01-29 09:17:18 -07001439#endif /* CONFIG_CMD_MX_CYCLIC */
Simon Glass15a33e42012-11-30 13:01:20 +00001440
1441#ifdef CONFIG_CMD_MEMINFO
1442U_BOOT_CMD(
1443 meminfo, 3, 1, do_mem_info,
1444 "display memory information",
1445 ""
1446);
1447#endif
Jean-Jacques Hiblot803e1a32019-07-02 14:23:26 +02001448
1449#ifdef CONFIG_CMD_RANDOM
1450U_BOOT_CMD(
1451 random, 4, 0, do_random,
1452 "fill memory with random pattern",
1453 "<addr> <len> [<seed>]\n"
1454 " - Fill 'len' bytes of memory starting at 'addr' with random data\n"
1455);
1456#endif