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