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