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