Merge branch 'master' of git://git.denx.de/u-boot-mips
[platform/kernel/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;
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_CRC32_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_CRC32_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_CRC32_VERIFY */
1324
1325 #endif
1326
1327 #ifdef CONFIG_CMD_MEMINFO
1328 __weak void board_show_dram(ulong 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