blob: 28476d750b0e6f76a87fa8c7a9eb0d823365e682 [file] [log] [blame]
wdenk38635852002-08-27 05:55:31 +00001/*
2 * (C) Copyright 2000
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21 * MA 02111-1307 USA
22 */
23
24/*
25 * Memory Functions
26 *
27 * Copied from FADS ROM, Dan Malek (dmalek@jlc.net)
28 */
29
30#include <common.h>
31#include <command.h>
wdenk2abbe072003-06-16 23:50:08 +000032#ifdef CONFIG_HAS_DATAFLASH
33#include <dataflash.h>
34#endif
Sergei Poselenova6e6fc62008-04-09 16:09:41 +020035#include <watchdog.h>
wdenk38635852002-08-27 05:55:31 +000036
wdenk38635852002-08-27 05:55:31 +000037#ifdef CMD_MEM_DEBUG
38#define PRINTF(fmt,args...) printf (fmt ,##args)
39#else
40#define PRINTF(fmt,args...)
41#endif
42
Wolfgang Denk54841ab2010-06-28 22:00:46 +020043static int mod_mem(cmd_tbl_t *, 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 */
Mike Frysingerd6efe242010-12-22 09:40:29 -050048static uint dp_last_addr, dp_last_size;
49static uint dp_last_length = 0x40;
50static uint mm_last_addr, mm_last_size;
wdenk38635852002-08-27 05:55:31 +000051
52static ulong base_address = 0;
53
54/* Memory Display
55 *
56 * Syntax:
57 * md{.b, .w, .l} {addr} {len}
58 */
59#define DISP_LINE_LEN 16
Wolfgang Denk54841ab2010-06-28 22:00:46 +020060int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +000061{
wdenk27b207f2003-07-24 23:38:38 +000062 ulong addr, length;
Grant Likelyc95c4282007-02-20 09:05:00 +010063#if defined(CONFIG_HAS_DATAFLASH)
64 ulong nbytes, linebytes;
65#endif
wdenk27b207f2003-07-24 23:38:38 +000066 int size;
wdenk38635852002-08-27 05:55:31 +000067 int rc = 0;
68
69 /* We use the last specified parameters, unless new ones are
70 * entered.
71 */
72 addr = dp_last_addr;
73 size = dp_last_size;
74 length = dp_last_length;
75
Wolfgang Denk47e26b12010-07-17 01:06:04 +020076 if (argc < 2)
77 return cmd_usage(cmdtp);
wdenk38635852002-08-27 05:55:31 +000078
79 if ((flag & CMD_FLAG_REPEAT) == 0) {
80 /* New command specified. Check for a size specification.
81 * Defaults to long if no or incorrect specification.
82 */
wdenk27b207f2003-07-24 23:38:38 +000083 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
84 return 1;
wdenk38635852002-08-27 05:55:31 +000085
86 /* Address is specified since argc > 1
87 */
88 addr = simple_strtoul(argv[1], NULL, 16);
89 addr += base_address;
90
91 /* If another parameter, it is the length to display.
92 * Length is the number of objects, not number of bytes.
93 */
94 if (argc > 2)
95 length = simple_strtoul(argv[2], NULL, 16);
96 }
97
Grant Likelyc95c4282007-02-20 09:05:00 +010098#if defined(CONFIG_HAS_DATAFLASH)
wdenk38635852002-08-27 05:55:31 +000099 /* Print the lines.
100 *
101 * We buffer all read data, so we can make sure data is read only
102 * once, and all accesses are with the specified bus width.
103 */
104 nbytes = length * size;
105 do {
106 char linebuf[DISP_LINE_LEN];
Grant Likelyc95c4282007-02-20 09:05:00 +0100107 void* p;
wdenk38635852002-08-27 05:55:31 +0000108 linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;
wdenk2abbe072003-06-16 23:50:08 +0000109
Grant Likelyc95c4282007-02-20 09:05:00 +0100110 rc = read_dataflash(addr, (linebytes/size)*size, linebuf);
111 p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr;
112 print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size);
wdenk8bde7f72003-06-27 21:31:46 +0000113
wdenk38635852002-08-27 05:55:31 +0000114 nbytes -= linebytes;
Grant Likelyc95c4282007-02-20 09:05:00 +0100115 addr += linebytes;
wdenk38635852002-08-27 05:55:31 +0000116 if (ctrlc()) {
117 rc = 1;
118 break;
119 }
120 } while (nbytes > 0);
Grant Likelyc95c4282007-02-20 09:05:00 +0100121#else
Mike Frysinger4c727c72008-02-04 19:26:56 -0500122
123# if defined(CONFIG_BLACKFIN)
124 /* See if we're trying to display L1 inst */
125 if (addr_bfin_on_chip_mem(addr)) {
126 char linebuf[DISP_LINE_LEN];
127 ulong linebytes, nbytes = length * size;
128 do {
129 linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
130 memcpy(linebuf, (void *)addr, linebytes);
131 print_buffer(addr, linebuf, size, linebytes/size, DISP_LINE_LEN/size);
132
133 nbytes -= linebytes;
134 addr += linebytes;
135 if (ctrlc()) {
136 rc = 1;
137 break;
138 }
139 } while (nbytes > 0);
140 } else
141# endif
142
143 {
144 /* Print the lines. */
145 print_buffer(addr, (void*)addr, size, length, DISP_LINE_LEN/size);
146 addr += size*length;
147 }
Grant Likelyc95c4282007-02-20 09:05:00 +0100148#endif
wdenk38635852002-08-27 05:55:31 +0000149
150 dp_last_addr = addr;
151 dp_last_length = length;
152 dp_last_size = size;
153 return (rc);
154}
155
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200156int do_mem_mm ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000157{
158 return mod_mem (cmdtp, 1, flag, argc, argv);
159}
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200160int do_mem_nm ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000161{
162 return mod_mem (cmdtp, 0, flag, argc, argv);
163}
164
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200165int do_mem_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000166{
wdenk27b207f2003-07-24 23:38:38 +0000167 ulong addr, writeval, count;
168 int size;
wdenk38635852002-08-27 05:55:31 +0000169
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200170 if ((argc < 3) || (argc > 4))
171 return cmd_usage(cmdtp);
wdenk38635852002-08-27 05:55:31 +0000172
173 /* Check for size specification.
174 */
wdenk27b207f2003-07-24 23:38:38 +0000175 if ((size = cmd_get_data_size(argv[0], 4)) < 1)
176 return 1;
wdenk38635852002-08-27 05:55:31 +0000177
178 /* Address is specified since argc > 1
179 */
180 addr = simple_strtoul(argv[1], NULL, 16);
181 addr += base_address;
182
183 /* Get the value to write.
184 */
185 writeval = simple_strtoul(argv[2], NULL, 16);
186
187 /* Count ? */
188 if (argc == 4) {
189 count = simple_strtoul(argv[3], NULL, 16);
190 } else {
191 count = 1;
192 }
193
194 while (count-- > 0) {
195 if (size == 4)
196 *((ulong *)addr) = (ulong )writeval;
197 else if (size == 2)
198 *((ushort *)addr) = (ushort)writeval;
199 else
200 *((u_char *)addr) = (u_char)writeval;
201 addr += size;
202 }
203 return 0;
204}
205
stroese4aaf29b2004-12-16 17:42:39 +0000206#ifdef CONFIG_MX_CYCLIC
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200207int do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
stroese4aaf29b2004-12-16 17:42:39 +0000208{
209 int i;
210 ulong count;
211
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200212 if (argc < 4)
213 return cmd_usage(cmdtp);
stroese4aaf29b2004-12-16 17:42:39 +0000214
215 count = simple_strtoul(argv[3], NULL, 10);
216
217 for (;;) {
218 do_mem_md (NULL, 0, 3, argv);
219
220 /* delay for <count> ms... */
221 for (i=0; i<count; i++)
222 udelay (1000);
223
224 /* check for ctrl-c to abort... */
225 if (ctrlc()) {
226 puts("Abort\n");
227 return 0;
228 }
229 }
230
231 return 0;
232}
233
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200234int do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
stroese4aaf29b2004-12-16 17:42:39 +0000235{
236 int i;
237 ulong count;
238
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200239 if (argc < 4)
240 return cmd_usage(cmdtp);
stroese4aaf29b2004-12-16 17:42:39 +0000241
242 count = simple_strtoul(argv[3], NULL, 10);
243
244 for (;;) {
245 do_mem_mw (NULL, 0, 3, argv);
246
247 /* delay for <count> ms... */
248 for (i=0; i<count; i++)
249 udelay (1000);
250
251 /* check for ctrl-c to abort... */
252 if (ctrlc()) {
253 puts("Abort\n");
254 return 0;
255 }
256 }
257
258 return 0;
259}
260#endif /* CONFIG_MX_CYCLIC */
261
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200262int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000263{
wdenk27b207f2003-07-24 23:38:38 +0000264 ulong addr1, addr2, count, ngood;
265 int size;
wdenk38635852002-08-27 05:55:31 +0000266 int rcode = 0;
267
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200268 if (argc != 4)
269 return cmd_usage(cmdtp);
wdenk38635852002-08-27 05:55:31 +0000270
271 /* Check for size specification.
272 */
wdenk27b207f2003-07-24 23:38:38 +0000273 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
274 return 1;
wdenk38635852002-08-27 05:55:31 +0000275
276 addr1 = simple_strtoul(argv[1], NULL, 16);
277 addr1 += base_address;
278
279 addr2 = simple_strtoul(argv[2], NULL, 16);
280 addr2 += base_address;
281
282 count = simple_strtoul(argv[3], NULL, 16);
283
wdenk2abbe072003-06-16 23:50:08 +0000284#ifdef CONFIG_HAS_DATAFLASH
285 if (addr_dataflash(addr1) | addr_dataflash(addr2)){
wdenk4b9206e2004-03-23 22:14:11 +0000286 puts ("Comparison with DataFlash space not supported.\n\r");
wdenk2abbe072003-06-16 23:50:08 +0000287 return 0;
288 }
289#endif
290
Mike Frysinger4c727c72008-02-04 19:26:56 -0500291#ifdef CONFIG_BLACKFIN
292 if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) {
293 puts ("Comparison with L1 instruction memory not supported.\n\r");
294 return 0;
295 }
296#endif
297
wdenk38635852002-08-27 05:55:31 +0000298 ngood = 0;
299
300 while (count-- > 0) {
301 if (size == 4) {
302 ulong word1 = *(ulong *)addr1;
303 ulong word2 = *(ulong *)addr2;
304 if (word1 != word2) {
305 printf("word at 0x%08lx (0x%08lx) "
306 "!= word at 0x%08lx (0x%08lx)\n",
307 addr1, word1, addr2, word2);
308 rcode = 1;
309 break;
310 }
311 }
312 else if (size == 2) {
313 ushort hword1 = *(ushort *)addr1;
314 ushort hword2 = *(ushort *)addr2;
315 if (hword1 != hword2) {
316 printf("halfword at 0x%08lx (0x%04x) "
317 "!= halfword at 0x%08lx (0x%04x)\n",
318 addr1, hword1, addr2, hword2);
319 rcode = 1;
320 break;
321 }
322 }
323 else {
324 u_char byte1 = *(u_char *)addr1;
325 u_char byte2 = *(u_char *)addr2;
326 if (byte1 != byte2) {
327 printf("byte at 0x%08lx (0x%02x) "
328 "!= byte at 0x%08lx (0x%02x)\n",
329 addr1, byte1, addr2, byte2);
330 rcode = 1;
331 break;
332 }
333 }
334 ngood++;
335 addr1 += size;
336 addr2 += size;
Stefan Roeseeaadb442010-09-13 11:10:34 +0200337
338 /* reset watchdog from time to time */
339 if ((count % (64 << 10)) == 0)
340 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000341 }
342
343 printf("Total of %ld %s%s were the same\n",
344 ngood, size == 4 ? "word" : size == 2 ? "halfword" : "byte",
345 ngood == 1 ? "" : "s");
346 return rcode;
347}
348
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200349int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000350{
wdenk27b207f2003-07-24 23:38:38 +0000351 ulong addr, dest, count;
352 int size;
wdenk38635852002-08-27 05:55:31 +0000353
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200354 if (argc != 4)
355 return cmd_usage(cmdtp);
wdenk38635852002-08-27 05:55:31 +0000356
357 /* Check for size specification.
358 */
wdenk27b207f2003-07-24 23:38:38 +0000359 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
360 return 1;
wdenk38635852002-08-27 05:55:31 +0000361
362 addr = simple_strtoul(argv[1], NULL, 16);
363 addr += base_address;
364
365 dest = simple_strtoul(argv[2], NULL, 16);
366 dest += base_address;
367
368 count = simple_strtoul(argv[3], NULL, 16);
369
370 if (count == 0) {
371 puts ("Zero length ???\n");
372 return 1;
373 }
374
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200375#ifndef CONFIG_SYS_NO_FLASH
wdenk38635852002-08-27 05:55:31 +0000376 /* check if we are copying to Flash */
wdenk2abbe072003-06-16 23:50:08 +0000377 if ( (addr2info(dest) != NULL)
378#ifdef CONFIG_HAS_DATAFLASH
Kim B. Heino84d0c2f2008-03-03 10:39:13 +0200379 && (!addr_dataflash(dest))
wdenk2abbe072003-06-16 23:50:08 +0000380#endif
381 ) {
wdenk38635852002-08-27 05:55:31 +0000382 int rc;
383
wdenk4b9206e2004-03-23 22:14:11 +0000384 puts ("Copy to Flash... ");
wdenk38635852002-08-27 05:55:31 +0000385
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200386 rc = flash_write ((char *)addr, dest, count*size);
wdenk38635852002-08-27 05:55:31 +0000387 if (rc != 0) {
388 flash_perror (rc);
389 return (1);
390 }
391 puts ("done\n");
392 return 0;
393 }
394#endif
395
wdenk2abbe072003-06-16 23:50:08 +0000396#ifdef CONFIG_HAS_DATAFLASH
397 /* Check if we are copying from RAM or Flash to DataFlash */
398 if (addr_dataflash(dest) && !addr_dataflash(addr)){
399 int rc;
400
wdenk4b9206e2004-03-23 22:14:11 +0000401 puts ("Copy to DataFlash... ");
wdenk2abbe072003-06-16 23:50:08 +0000402
403 rc = write_dataflash (dest, addr, count*size);
404
405 if (rc != 1) {
406 dataflash_perror (rc);
407 return (1);
408 }
409 puts ("done\n");
410 return 0;
411 }
wdenk8bde7f72003-06-27 21:31:46 +0000412
wdenk2abbe072003-06-16 23:50:08 +0000413 /* Check if we are copying from DataFlash to RAM */
Stelian Pop880cc432008-03-26 22:52:35 +0100414 if (addr_dataflash(addr) && !addr_dataflash(dest)
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200415#ifndef CONFIG_SYS_NO_FLASH
Stelian Pop880cc432008-03-26 22:52:35 +0100416 && (addr2info(dest) == NULL)
417#endif
418 ){
wdenk5779d8d2003-12-06 23:55:10 +0000419 int rc;
420 rc = read_dataflash(addr, count * size, (char *) dest);
421 if (rc != 1) {
wdenkd4ca31c2004-01-02 14:00:00 +0000422 dataflash_perror (rc);
423 return (1);
424 }
wdenk2abbe072003-06-16 23:50:08 +0000425 return 0;
426 }
427
428 if (addr_dataflash(addr) && addr_dataflash(dest)){
wdenk4b9206e2004-03-23 22:14:11 +0000429 puts ("Unsupported combination of source/destination.\n\r");
wdenk2abbe072003-06-16 23:50:08 +0000430 return 1;
431 }
432#endif
433
Mike Frysinger4c727c72008-02-04 19:26:56 -0500434#ifdef CONFIG_BLACKFIN
435 /* See if we're copying to/from L1 inst */
436 if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) {
437 memcpy((void *)dest, (void *)addr, count * size);
438 return 0;
439 }
440#endif
441
wdenk38635852002-08-27 05:55:31 +0000442 while (count-- > 0) {
443 if (size == 4)
444 *((ulong *)dest) = *((ulong *)addr);
445 else if (size == 2)
446 *((ushort *)dest) = *((ushort *)addr);
447 else
448 *((u_char *)dest) = *((u_char *)addr);
449 addr += size;
450 dest += size;
Stefan Roeseeaadb442010-09-13 11:10:34 +0200451
452 /* reset watchdog from time to time */
453 if ((count % (64 << 10)) == 0)
454 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000455 }
456 return 0;
457}
458
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200459int do_mem_base (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000460{
461 if (argc > 1) {
462 /* Set new base address.
463 */
464 base_address = simple_strtoul(argv[1], NULL, 16);
465 }
466 /* Print the current base address.
467 */
468 printf("Base Address: 0x%08lx\n", base_address);
469 return 0;
470}
471
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200472int do_mem_loop (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000473{
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200474 ulong addr, length, i;
wdenk27b207f2003-07-24 23:38:38 +0000475 int size;
wdenk38635852002-08-27 05:55:31 +0000476 volatile uint *longp;
477 volatile ushort *shortp;
478 volatile u_char *cp;
479
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200480 if (argc < 3)
481 return cmd_usage(cmdtp);
wdenk38635852002-08-27 05:55:31 +0000482
483 /* Check for a size spefication.
484 * Defaults to long if no or incorrect specification.
485 */
wdenk27b207f2003-07-24 23:38:38 +0000486 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
487 return 1;
wdenk38635852002-08-27 05:55:31 +0000488
489 /* Address is always specified.
490 */
491 addr = simple_strtoul(argv[1], NULL, 16);
492
493 /* Length is the number of objects, not number of bytes.
494 */
495 length = simple_strtoul(argv[2], NULL, 16);
496
497 /* We want to optimize the loops to run as fast as possible.
498 * If we have only one object, just run infinite loops.
499 */
500 if (length == 1) {
501 if (size == 4) {
502 longp = (uint *)addr;
503 for (;;)
504 i = *longp;
505 }
506 if (size == 2) {
507 shortp = (ushort *)addr;
508 for (;;)
509 i = *shortp;
510 }
511 cp = (u_char *)addr;
512 for (;;)
513 i = *cp;
514 }
515
516 if (size == 4) {
517 for (;;) {
518 longp = (uint *)addr;
519 i = length;
520 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200521 *longp++;
wdenk38635852002-08-27 05:55:31 +0000522 }
523 }
524 if (size == 2) {
525 for (;;) {
526 shortp = (ushort *)addr;
527 i = length;
528 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200529 *shortp++;
wdenk38635852002-08-27 05:55:31 +0000530 }
531 }
532 for (;;) {
533 cp = (u_char *)addr;
534 i = length;
535 while (i-- > 0)
Marek Vasutf3b3c3d2011-09-26 02:26:06 +0200536 *cp++;
wdenk38635852002-08-27 05:55:31 +0000537 }
538}
539
wdenk56523f12004-07-11 17:40:54 +0000540#ifdef CONFIG_LOOPW
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200541int do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk56523f12004-07-11 17:40:54 +0000542{
543 ulong addr, length, i, data;
544 int size;
545 volatile uint *longp;
546 volatile ushort *shortp;
547 volatile u_char *cp;
wdenk81050922004-07-11 20:04:51 +0000548
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200549 if (argc < 4)
550 return cmd_usage(cmdtp);
wdenk56523f12004-07-11 17:40:54 +0000551
552 /* Check for a size spefication.
553 * Defaults to long if no or incorrect specification.
554 */
555 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
556 return 1;
557
558 /* Address is always specified.
559 */
560 addr = simple_strtoul(argv[1], NULL, 16);
561
562 /* Length is the number of objects, not number of bytes.
563 */
564 length = simple_strtoul(argv[2], NULL, 16);
565
566 /* data to write */
567 data = simple_strtoul(argv[3], NULL, 16);
wdenk81050922004-07-11 20:04:51 +0000568
wdenk56523f12004-07-11 17:40:54 +0000569 /* We want to optimize the loops to run as fast as possible.
570 * If we have only one object, just run infinite loops.
571 */
572 if (length == 1) {
573 if (size == 4) {
574 longp = (uint *)addr;
575 for (;;)
576 *longp = data;
577 }
578 if (size == 2) {
579 shortp = (ushort *)addr;
580 for (;;)
581 *shortp = data;
582 }
583 cp = (u_char *)addr;
584 for (;;)
585 *cp = data;
586 }
587
588 if (size == 4) {
589 for (;;) {
590 longp = (uint *)addr;
591 i = length;
592 while (i-- > 0)
593 *longp++ = data;
594 }
595 }
596 if (size == 2) {
597 for (;;) {
598 shortp = (ushort *)addr;
599 i = length;
600 while (i-- > 0)
601 *shortp++ = data;
602 }
603 }
604 for (;;) {
605 cp = (u_char *)addr;
606 i = length;
607 while (i-- > 0)
608 *cp++ = data;
609 }
610}
611#endif /* CONFIG_LOOPW */
612
wdenk38635852002-08-27 05:55:31 +0000613/*
614 * Perform a memory test. A more complete alternative test can be
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200615 * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
wdenk38635852002-08-27 05:55:31 +0000616 * interrupted by ctrl-c or by a failure of one of the sub-tests.
617 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200618int do_mem_mtest (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000619{
620 vu_long *addr, *start, *end;
621 ulong val;
622 ulong readback;
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400623 ulong errs = 0;
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100624 int iterations = 1;
625 int iteration_limit;
wdenk38635852002-08-27 05:55:31 +0000626
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200627#if defined(CONFIG_SYS_ALT_MEMTEST)
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100628 vu_long len;
wdenk38635852002-08-27 05:55:31 +0000629 vu_long offset;
630 vu_long test_offset;
631 vu_long pattern;
632 vu_long temp;
633 vu_long anti_pattern;
634 vu_long num_words;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200635#if defined(CONFIG_SYS_MEMTEST_SCRATCH)
636 vu_long *dummy = (vu_long*)CONFIG_SYS_MEMTEST_SCRATCH;
wdenk5f535fe2003-09-18 09:21:33 +0000637#else
Wolfgang Denk029b6dc2006-07-21 11:37:40 +0200638 vu_long *dummy = 0; /* yes, this is address 0x0, not NULL */
wdenk5f535fe2003-09-18 09:21:33 +0000639#endif
wdenk38635852002-08-27 05:55:31 +0000640 int j;
wdenk38635852002-08-27 05:55:31 +0000641
642 static const ulong bitpattern[] = {
643 0x00000001, /* single bit */
644 0x00000003, /* two adjacent bits */
645 0x00000007, /* three adjacent bits */
646 0x0000000F, /* four adjacent bits */
647 0x00000005, /* two non-adjacent bits */
648 0x00000015, /* three non-adjacent bits */
649 0x00000055, /* four non-adjacent bits */
650 0xaaaaaaaa, /* alternating 1/0 */
651 };
652#else
653 ulong incr;
654 ulong pattern;
wdenk38635852002-08-27 05:55:31 +0000655#endif
656
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100657 if (argc > 1)
wdenk38635852002-08-27 05:55:31 +0000658 start = (ulong *)simple_strtoul(argv[1], NULL, 16);
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100659 else
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200660 start = (ulong *)CONFIG_SYS_MEMTEST_START;
wdenk38635852002-08-27 05:55:31 +0000661
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100662 if (argc > 2)
wdenk38635852002-08-27 05:55:31 +0000663 end = (ulong *)simple_strtoul(argv[2], NULL, 16);
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100664 else
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200665 end = (ulong *)(CONFIG_SYS_MEMTEST_END);
wdenk38635852002-08-27 05:55:31 +0000666
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100667 if (argc > 3)
wdenk38635852002-08-27 05:55:31 +0000668 pattern = (ulong)simple_strtoul(argv[3], NULL, 16);
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100669 else
wdenk38635852002-08-27 05:55:31 +0000670 pattern = 0;
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100671
672 if (argc > 4)
673 iteration_limit = (ulong)simple_strtoul(argv[4], NULL, 16);
674 else
675 iteration_limit = 0;
wdenk38635852002-08-27 05:55:31 +0000676
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200677#if defined(CONFIG_SYS_ALT_MEMTEST)
wdenk38635852002-08-27 05:55:31 +0000678 printf ("Testing %08x ... %08x:\n", (uint)start, (uint)end);
679 PRINTF("%s:%d: start 0x%p end 0x%p\n",
680 __FUNCTION__, __LINE__, start, end);
681
682 for (;;) {
683 if (ctrlc()) {
684 putc ('\n');
685 return 1;
686 }
687
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100688
689 if (iteration_limit && iterations > iteration_limit) {
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400690 printf("Tested %d iteration(s) with %lu errors.\n",
691 iterations-1, errs);
692 return errs != 0;
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100693 }
694
wdenk38635852002-08-27 05:55:31 +0000695 printf("Iteration: %6d\r", iterations);
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100696 PRINTF("\n");
wdenk38635852002-08-27 05:55:31 +0000697 iterations++;
698
699 /*
700 * Data line test: write a pattern to the first
701 * location, write the 1's complement to a 'parking'
702 * address (changes the state of the data bus so a
703 * floating bus doen't give a false OK), and then
704 * read the value back. Note that we read it back
705 * into a variable because the next time we read it,
706 * it might be right (been there, tough to explain to
707 * the quality guys why it prints a failure when the
708 * "is" and "should be" are obviously the same in the
709 * error message).
710 *
711 * Rather than exhaustively testing, we test some
712 * patterns by shifting '1' bits through a field of
713 * '0's and '0' bits through a field of '1's (i.e.
714 * pattern and ~pattern).
715 */
716 addr = start;
717 for (j = 0; j < sizeof(bitpattern)/sizeof(bitpattern[0]); j++) {
718 val = bitpattern[j];
719 for(; val != 0; val <<= 1) {
720 *addr = val;
721 *dummy = ~val; /* clear the test data off of the bus */
722 readback = *addr;
723 if(readback != val) {
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400724 printf ("FAILURE (data line): "
wdenk38635852002-08-27 05:55:31 +0000725 "expected %08lx, actual %08lx\n",
726 val, readback);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400727 errs++;
728 if (ctrlc()) {
729 putc ('\n');
730 return 1;
731 }
wdenk38635852002-08-27 05:55:31 +0000732 }
733 *addr = ~val;
734 *dummy = val;
735 readback = *addr;
736 if(readback != ~val) {
737 printf ("FAILURE (data line): "
738 "Is %08lx, should be %08lx\n",
wdenke1599e82004-10-10 23:27:33 +0000739 readback, ~val);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400740 errs++;
741 if (ctrlc()) {
742 putc ('\n');
743 return 1;
744 }
wdenk38635852002-08-27 05:55:31 +0000745 }
746 }
747 }
748
749 /*
750 * Based on code whose Original Author and Copyright
751 * information follows: Copyright (c) 1998 by Michael
752 * Barr. This software is placed into the public
753 * domain and may be used for any purpose. However,
754 * this notice must not be changed or removed and no
755 * warranty is either expressed or implied by its
756 * publication or distribution.
757 */
758
759 /*
760 * Address line test
761 *
762 * Description: Test the address bus wiring in a
763 * memory region by performing a walking
764 * 1's test on the relevant bits of the
765 * address and checking for aliasing.
766 * This test will find single-bit
767 * address failures such as stuck -high,
768 * stuck-low, and shorted pins. The base
769 * address and size of the region are
770 * selected by the caller.
771 *
772 * Notes: For best results, the selected base
773 * address should have enough LSB 0's to
774 * guarantee single address bit changes.
775 * For example, to test a 64-Kbyte
776 * region, select a base address on a
777 * 64-Kbyte boundary. Also, select the
778 * region size as a power-of-two if at
779 * all possible.
780 *
781 * Returns: 0 if the test succeeds, 1 if the test fails.
wdenk38635852002-08-27 05:55:31 +0000782 */
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100783 len = ((ulong)end - (ulong)start)/sizeof(vu_long);
wdenk38635852002-08-27 05:55:31 +0000784 pattern = (vu_long) 0xaaaaaaaa;
785 anti_pattern = (vu_long) 0x55555555;
786
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100787 PRINTF("%s:%d: length = 0x%.8lx\n",
wdenk38635852002-08-27 05:55:31 +0000788 __FUNCTION__, __LINE__,
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100789 len);
wdenk38635852002-08-27 05:55:31 +0000790 /*
791 * Write the default pattern at each of the
792 * power-of-two offsets.
793 */
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100794 for (offset = 1; offset < len; offset <<= 1) {
wdenk38635852002-08-27 05:55:31 +0000795 start[offset] = pattern;
796 }
797
798 /*
799 * Check for address bits stuck high.
800 */
801 test_offset = 0;
802 start[test_offset] = anti_pattern;
803
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100804 for (offset = 1; offset < len; offset <<= 1) {
wdenk38635852002-08-27 05:55:31 +0000805 temp = start[offset];
806 if (temp != pattern) {
807 printf ("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
808 " expected 0x%.8lx, actual 0x%.8lx\n",
809 (ulong)&start[offset], pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400810 errs++;
811 if (ctrlc()) {
812 putc ('\n');
813 return 1;
814 }
wdenk38635852002-08-27 05:55:31 +0000815 }
816 }
817 start[test_offset] = pattern;
Sergei Poselenova6e6fc62008-04-09 16:09:41 +0200818 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000819
820 /*
821 * Check for addr bits stuck low or shorted.
822 */
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100823 for (test_offset = 1; test_offset < len; test_offset <<= 1) {
wdenk38635852002-08-27 05:55:31 +0000824 start[test_offset] = anti_pattern;
825
Guennadi Liakhovetski6f4abee2008-02-08 21:25:58 +0100826 for (offset = 1; offset < len; offset <<= 1) {
wdenk38635852002-08-27 05:55:31 +0000827 temp = start[offset];
828 if ((temp != pattern) && (offset != test_offset)) {
829 printf ("\nFAILURE: Address bit stuck low or shorted @"
830 " 0x%.8lx: expected 0x%.8lx, actual 0x%.8lx\n",
831 (ulong)&start[offset], pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400832 errs++;
833 if (ctrlc()) {
834 putc ('\n');
835 return 1;
836 }
wdenk38635852002-08-27 05:55:31 +0000837 }
838 }
839 start[test_offset] = pattern;
840 }
841
842 /*
843 * Description: Test the integrity of a physical
844 * memory device by performing an
845 * increment/decrement test over the
846 * entire region. In the process every
847 * storage bit in the device is tested
848 * as a zero and a one. The base address
849 * and the size of the region are
850 * selected by the caller.
851 *
852 * Returns: 0 if the test succeeds, 1 if the test fails.
853 */
854 num_words = ((ulong)end - (ulong)start)/sizeof(vu_long) + 1;
855
856 /*
857 * Fill memory with a known pattern.
858 */
859 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
Sergei Poselenova6e6fc62008-04-09 16:09:41 +0200860 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000861 start[offset] = pattern;
862 }
863
864 /*
865 * Check each location and invert it for the second pass.
866 */
867 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
Sergei Poselenova6e6fc62008-04-09 16:09:41 +0200868 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000869 temp = start[offset];
870 if (temp != pattern) {
871 printf ("\nFAILURE (read/write) @ 0x%.8lx:"
872 " expected 0x%.8lx, actual 0x%.8lx)\n",
873 (ulong)&start[offset], pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400874 errs++;
875 if (ctrlc()) {
876 putc ('\n');
877 return 1;
878 }
wdenk38635852002-08-27 05:55:31 +0000879 }
880
881 anti_pattern = ~pattern;
882 start[offset] = anti_pattern;
883 }
884
885 /*
886 * Check each location for the inverted pattern and zero it.
887 */
888 for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
Sergei Poselenova6e6fc62008-04-09 16:09:41 +0200889 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000890 anti_pattern = ~pattern;
891 temp = start[offset];
892 if (temp != anti_pattern) {
893 printf ("\nFAILURE (read/write): @ 0x%.8lx:"
894 " expected 0x%.8lx, actual 0x%.8lx)\n",
895 (ulong)&start[offset], anti_pattern, temp);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400896 errs++;
897 if (ctrlc()) {
898 putc ('\n');
899 return 1;
900 }
wdenk38635852002-08-27 05:55:31 +0000901 }
902 start[offset] = 0;
903 }
904 }
905
906#else /* The original, quickie test */
907 incr = 1;
908 for (;;) {
909 if (ctrlc()) {
910 putc ('\n');
911 return 1;
912 }
913
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100914 if (iteration_limit && iterations > iteration_limit) {
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400915 printf("Tested %d iteration(s) with %lu errors.\n",
916 iterations-1, errs);
917 return errs != 0;
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +0100918 }
919 ++iterations;
920
wdenk38635852002-08-27 05:55:31 +0000921 printf ("\rPattern %08lX Writing..."
922 "%12s"
923 "\b\b\b\b\b\b\b\b\b\b",
924 pattern, "");
925
926 for (addr=start,val=pattern; addr<end; addr++) {
Sergei Poselenova6e6fc62008-04-09 16:09:41 +0200927 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000928 *addr = val;
929 val += incr;
930 }
931
wdenk4b9206e2004-03-23 22:14:11 +0000932 puts ("Reading...");
wdenk38635852002-08-27 05:55:31 +0000933
934 for (addr=start,val=pattern; addr<end; addr++) {
Sergei Poselenova6e6fc62008-04-09 16:09:41 +0200935 WATCHDOG_RESET();
wdenk38635852002-08-27 05:55:31 +0000936 readback = *addr;
937 if (readback != val) {
938 printf ("\nMem error @ 0x%08X: "
939 "found %08lX, expected %08lX\n",
Simon Glass92549352011-09-17 06:48:58 +0000940 (uint)(uintptr_t)addr, readback, val);
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400941 errs++;
942 if (ctrlc()) {
943 putc ('\n');
944 return 1;
945 }
wdenk38635852002-08-27 05:55:31 +0000946 }
947 val += incr;
948 }
949
950 /*
951 * Flip the pattern each time to make lots of zeros and
952 * then, the next time, lots of ones. We decrement
953 * the "negative" patterns and increment the "positive"
954 * patterns to preserve this feature.
955 */
956 if(pattern & 0x80000000) {
957 pattern = -pattern; /* complement & increment */
958 }
959 else {
960 pattern = ~pattern;
961 }
962 incr = -incr;
963 }
wdenk38635852002-08-27 05:55:31 +0000964#endif
Paul Gortmaker87b22b72009-10-02 18:18:33 -0400965 return 0; /* not reached */
wdenk38635852002-08-27 05:55:31 +0000966}
967
968
969/* Modify memory.
970 *
971 * Syntax:
972 * mm{.b, .w, .l} {addr}
973 * nm{.b, .w, .l} {addr}
974 */
975static int
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200976mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +0000977{
wdenk27b207f2003-07-24 23:38:38 +0000978 ulong addr, i;
979 int nbytes, size;
wdenk38635852002-08-27 05:55:31 +0000980 extern char console_buffer[];
981
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200982 if (argc != 2)
983 return cmd_usage(cmdtp);
wdenk38635852002-08-27 05:55:31 +0000984
985#ifdef CONFIG_BOOT_RETRY_TIME
986 reset_cmd_timeout(); /* got a good command to get here */
987#endif
988 /* We use the last specified parameters, unless new ones are
989 * entered.
990 */
991 addr = mm_last_addr;
992 size = mm_last_size;
993
994 if ((flag & CMD_FLAG_REPEAT) == 0) {
995 /* New command specified. Check for a size specification.
996 * Defaults to long if no or incorrect specification.
997 */
wdenk27b207f2003-07-24 23:38:38 +0000998 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
999 return 1;
wdenk38635852002-08-27 05:55:31 +00001000
1001 /* Address is specified since argc > 1
1002 */
1003 addr = simple_strtoul(argv[1], NULL, 16);
1004 addr += base_address;
1005 }
1006
wdenk2abbe072003-06-16 23:50:08 +00001007#ifdef CONFIG_HAS_DATAFLASH
1008 if (addr_dataflash(addr)){
wdenk4b9206e2004-03-23 22:14:11 +00001009 puts ("Can't modify DataFlash in place. Use cp instead.\n\r");
wdenk2abbe072003-06-16 23:50:08 +00001010 return 0;
1011 }
1012#endif
1013
Mike Frysinger4c727c72008-02-04 19:26:56 -05001014#ifdef CONFIG_BLACKFIN
1015 if (addr_bfin_on_chip_mem(addr)) {
1016 puts ("Can't modify L1 instruction in place. Use cp instead.\n\r");
1017 return 0;
1018 }
1019#endif
1020
wdenk38635852002-08-27 05:55:31 +00001021 /* Print the address, followed by value. Then accept input for
1022 * the next value. A non-converted value exits.
1023 */
1024 do {
1025 printf("%08lx:", addr);
1026 if (size == 4)
1027 printf(" %08x", *((uint *)addr));
1028 else if (size == 2)
1029 printf(" %04x", *((ushort *)addr));
1030 else
1031 printf(" %02x", *((u_char *)addr));
1032
1033 nbytes = readline (" ? ");
1034 if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
1035 /* <CR> pressed as only input, don't modify current
1036 * location and move to next. "-" pressed will go back.
1037 */
1038 if (incrflag)
1039 addr += nbytes ? -size : size;
1040 nbytes = 1;
1041#ifdef CONFIG_BOOT_RETRY_TIME
1042 reset_cmd_timeout(); /* good enough to not time out */
1043#endif
1044 }
1045#ifdef CONFIG_BOOT_RETRY_TIME
1046 else if (nbytes == -2) {
1047 break; /* timed out, exit the command */
1048 }
1049#endif
1050 else {
1051 char *endp;
1052 i = simple_strtoul(console_buffer, &endp, 16);
1053 nbytes = endp - console_buffer;
1054 if (nbytes) {
1055#ifdef CONFIG_BOOT_RETRY_TIME
1056 /* good enough to not time out
1057 */
1058 reset_cmd_timeout();
1059#endif
1060 if (size == 4)
1061 *((uint *)addr) = i;
1062 else if (size == 2)
1063 *((ushort *)addr) = i;
1064 else
1065 *((u_char *)addr) = i;
1066 if (incrflag)
1067 addr += size;
1068 }
1069 }
1070 } while (nbytes);
1071
1072 mm_last_addr = addr;
1073 mm_last_size = size;
1074 return 0;
1075}
1076
Mike Frysinger710b9932010-12-21 14:19:51 -05001077#ifdef CONFIG_CMD_CRC32
1078
wdenkc26e4542004-04-18 10:13:26 +00001079#ifndef CONFIG_CRC32_VERIFY
1080
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001081int do_mem_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk38635852002-08-27 05:55:31 +00001082{
wdenk71f95112003-06-15 22:40:42 +00001083 ulong addr, length;
1084 ulong crc;
1085 ulong *ptr;
wdenk38635852002-08-27 05:55:31 +00001086
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001087 if (argc < 3)
1088 return cmd_usage(cmdtp);
wdenk38635852002-08-27 05:55:31 +00001089
wdenk71f95112003-06-15 22:40:42 +00001090 addr = simple_strtoul (argv[1], NULL, 16);
wdenk38635852002-08-27 05:55:31 +00001091 addr += base_address;
1092
wdenk71f95112003-06-15 22:40:42 +00001093 length = simple_strtoul (argv[2], NULL, 16);
wdenk38635852002-08-27 05:55:31 +00001094
Jens Scharsig39c6e032011-07-18 08:46:26 +02001095 crc = crc32_wd (0, (const uchar *) addr, length, CHUNKSZ_CRC32);
wdenk38635852002-08-27 05:55:31 +00001096
1097 printf ("CRC32 for %08lx ... %08lx ==> %08lx\n",
wdenk71f95112003-06-15 22:40:42 +00001098 addr, addr + length - 1, crc);
wdenk38635852002-08-27 05:55:31 +00001099
wdenk71f95112003-06-15 22:40:42 +00001100 if (argc > 3) {
1101 ptr = (ulong *) simple_strtoul (argv[3], NULL, 16);
1102 *ptr = crc;
1103 }
wdenk38635852002-08-27 05:55:31 +00001104
1105 return 0;
1106}
1107
wdenkc26e4542004-04-18 10:13:26 +00001108#else /* CONFIG_CRC32_VERIFY */
1109
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001110int do_mem_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenkc26e4542004-04-18 10:13:26 +00001111{
1112 ulong addr, length;
1113 ulong crc;
1114 ulong *ptr;
wdenk6e592382004-04-18 17:39:38 +00001115 ulong vcrc;
wdenkc26e4542004-04-18 10:13:26 +00001116 int verify;
1117 int ac;
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001118 char * const *av;
wdenkc26e4542004-04-18 10:13:26 +00001119
1120 if (argc < 3) {
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001121usage:
1122 return cmd_usage(cmdtp);
wdenkc26e4542004-04-18 10:13:26 +00001123 }
1124
1125 av = argv + 1;
1126 ac = argc - 1;
1127 if (strcmp(*av, "-v") == 0) {
1128 verify = 1;
1129 av++;
1130 ac--;
1131 if (ac < 3)
1132 goto usage;
1133 } else
1134 verify = 0;
1135
1136 addr = simple_strtoul(*av++, NULL, 16);
1137 addr += base_address;
1138 length = simple_strtoul(*av++, NULL, 16);
1139
Jens Scharsig39c6e032011-07-18 08:46:26 +02001140 crc = crc32_wd (0, (const uchar *) addr, length, CHUNKSZ_CRC32);
wdenkc26e4542004-04-18 10:13:26 +00001141
1142 if (!verify) {
1143 printf ("CRC32 for %08lx ... %08lx ==> %08lx\n",
1144 addr, addr + length - 1, crc);
1145 if (ac > 2) {
1146 ptr = (ulong *) simple_strtoul (*av++, NULL, 16);
1147 *ptr = crc;
1148 }
1149 } else {
1150 vcrc = simple_strtoul(*av++, NULL, 16);
1151 if (vcrc != crc) {
1152 printf ("CRC32 for %08lx ... %08lx ==> %08lx != %08lx ** ERROR **\n",
1153 addr, addr + length - 1, crc, vcrc);
1154 return 1;
1155 }
1156 }
1157
1158 return 0;
1159
1160}
1161#endif /* CONFIG_CRC32_VERIFY */
1162
Mike Frysinger710b9932010-12-21 14:19:51 -05001163#endif
1164
wdenk8bde7f72003-06-27 21:31:46 +00001165/**************************************************/
wdenk0d498392003-07-01 21:06:45 +00001166U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001167 md, 3, 1, do_mem_md,
Peter Tyser2fb26042009-01-27 18:03:12 -06001168 "memory display",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001169 "[.b, .w, .l] address [# of objects]"
wdenk8bde7f72003-06-27 21:31:46 +00001170);
1171
1172
wdenk0d498392003-07-01 21:06:45 +00001173U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001174 mm, 2, 1, do_mem_mm,
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001175 "memory modify (auto-incrementing address)",
1176 "[.b, .w, .l] address"
wdenk8bde7f72003-06-27 21:31:46 +00001177);
1178
1179
wdenk0d498392003-07-01 21:06:45 +00001180U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001181 nm, 2, 1, do_mem_nm,
Peter Tyser2fb26042009-01-27 18:03:12 -06001182 "memory modify (constant address)",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001183 "[.b, .w, .l] address"
wdenk8bde7f72003-06-27 21:31:46 +00001184);
1185
wdenk0d498392003-07-01 21:06:45 +00001186U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001187 mw, 4, 1, do_mem_mw,
Peter Tyser2fb26042009-01-27 18:03:12 -06001188 "memory write (fill)",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001189 "[.b, .w, .l] address value [count]"
wdenk8bde7f72003-06-27 21:31:46 +00001190);
1191
wdenk0d498392003-07-01 21:06:45 +00001192U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001193 cp, 4, 1, do_mem_cp,
Peter Tyser2fb26042009-01-27 18:03:12 -06001194 "memory copy",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001195 "[.b, .w, .l] source target count"
wdenk8bde7f72003-06-27 21:31:46 +00001196);
1197
wdenk0d498392003-07-01 21:06:45 +00001198U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001199 cmp, 4, 1, do_mem_cmp,
Peter Tyser2fb26042009-01-27 18:03:12 -06001200 "memory compare",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001201 "[.b, .w, .l] addr1 addr2 count"
wdenk8bde7f72003-06-27 21:31:46 +00001202);
1203
Mike Frysinger710b9932010-12-21 14:19:51 -05001204#ifdef CONFIG_CMD_CRC32
1205
wdenkc26e4542004-04-18 10:13:26 +00001206#ifndef CONFIG_CRC32_VERIFY
1207
wdenk0d498392003-07-01 21:06:45 +00001208U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001209 crc32, 4, 1, do_mem_crc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001210 "checksum calculation",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001211 "address count [addr]\n - compute CRC32 checksum [save at addr]"
wdenk8bde7f72003-06-27 21:31:46 +00001212);
1213
wdenkc26e4542004-04-18 10:13:26 +00001214#else /* CONFIG_CRC32_VERIFY */
1215
1216U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001217 crc32, 5, 1, do_mem_crc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001218 "checksum calculation",
wdenkc26e4542004-04-18 10:13:26 +00001219 "address count [addr]\n - compute CRC32 checksum [save at addr]\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001220 "-v address count crc\n - verify crc of memory area"
wdenkc26e4542004-04-18 10:13:26 +00001221);
1222
1223#endif /* CONFIG_CRC32_VERIFY */
1224
Mike Frysinger710b9932010-12-21 14:19:51 -05001225#endif
1226
wdenk0d498392003-07-01 21:06:45 +00001227U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001228 base, 2, 1, do_mem_base,
Peter Tyser2fb26042009-01-27 18:03:12 -06001229 "print or set address offset",
wdenk8bde7f72003-06-27 21:31:46 +00001230 "\n - print address offset for memory commands\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001231 "base off\n - set address offset for memory commands to 'off'"
wdenk8bde7f72003-06-27 21:31:46 +00001232);
1233
wdenk0d498392003-07-01 21:06:45 +00001234U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001235 loop, 3, 1, do_mem_loop,
Peter Tyser2fb26042009-01-27 18:03:12 -06001236 "infinite loop on address range",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001237 "[.b, .w, .l] address number_of_objects"
wdenk8bde7f72003-06-27 21:31:46 +00001238);
1239
wdenk56523f12004-07-11 17:40:54 +00001240#ifdef CONFIG_LOOPW
1241U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001242 loopw, 4, 1, do_mem_loopw,
Peter Tyser2fb26042009-01-27 18:03:12 -06001243 "infinite write loop on address range",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001244 "[.b, .w, .l] address number_of_objects data_to_write"
wdenk56523f12004-07-11 17:40:54 +00001245);
1246#endif /* CONFIG_LOOPW */
1247
wdenk0d498392003-07-01 21:06:45 +00001248U_BOOT_CMD(
Dirk Eibachb6fc6fd2008-12-16 14:51:56 +01001249 mtest, 5, 1, do_mem_mtest,
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001250 "simple RAM read/write test",
1251 "[start [end [pattern [iterations]]]]"
wdenk8bde7f72003-06-27 21:31:46 +00001252);
1253
stroese4aaf29b2004-12-16 17:42:39 +00001254#ifdef CONFIG_MX_CYCLIC
1255U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001256 mdc, 4, 1, do_mem_mdc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001257 "memory display cyclic",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001258 "[.b, .w, .l] address count delay(ms)"
stroese4aaf29b2004-12-16 17:42:39 +00001259);
1260
1261U_BOOT_CMD(
Wolfgang Denk53677ef2008-05-20 16:00:29 +02001262 mwc, 4, 1, do_mem_mwc,
Peter Tyser2fb26042009-01-27 18:03:12 -06001263 "memory write cyclic",
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001264 "[.b, .w, .l] address value delay(ms)"
stroese4aaf29b2004-12-16 17:42:39 +00001265);
1266#endif /* CONFIG_MX_CYCLIC */