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