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