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