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