cmd/mem.c

   1 /*
   2  * (C) Copyright 2000
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 /*
   9  * Memory Functions
  10  *
  11  * Copied from FADS ROM, Dan Malek (dmalek@jlc.net)
  12  */
  13
  14 #include <common.h>
  15 #include <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;
 376         int     size;
 377
 378         if (argc != 4)
 379                 return CMD_RET_USAGE;
 380
 381         /* Check for size specification.
 382         */
 383         if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 384                 return 1;
 385
 386         addr = simple_strtoul(argv[1], NULL, 16);
 387         addr += base_address;
 388
 389         dest = simple_strtoul(argv[2], NULL, 16);
 390         dest += base_address;
 391
 392         count = simple_strtoul(argv[3], NULL, 16);
 393
 394         if (count == 0) {
 395                 puts ("Zero length ???\n");
 396                 return 1;
 397         }
 398
 399 #ifdef CONFIG_MTD_NOR_FLASH
 400         /* check if we are copying to Flash */
 401         if ( (addr2info(dest) != NULL)
 402 #ifdef CONFIG_HAS_DATAFLASH
 403            && (!addr_dataflash(dest))
 404 #endif
 405            ) {
 406                 int rc;
 407
 408                 puts ("Copy to Flash... ");
 409
 410                 rc = flash_write ((char *)addr, dest, count*size);
 411                 if (rc != 0) {
 412                         flash_perror (rc);
 413                         return (1);
 414                 }
 415                 puts ("done\n");
 416                 return 0;
 417         }
 418 #endif
 419
 420 #ifdef CONFIG_HAS_DATAFLASH
 421         /* Check if we are copying from RAM or Flash to DataFlash */
 422         if (addr_dataflash(dest) && !addr_dataflash(addr)){
 423                 int rc;
 424
 425                 puts ("Copy to DataFlash... ");
 426
 427                 rc = write_dataflash (dest, addr, count*size);
 428
 429                 if (rc != 1) {
 430                         dataflash_perror (rc);
 431                         return (1);
 432                 }
 433                 puts ("done\n");
 434                 return 0;
 435         }
 436
 437         /* Check if we are copying from DataFlash to RAM */
 438         if (addr_dataflash(addr) && !addr_dataflash(dest)
 439 #ifdef CONFIG_MTD_NOR_FLASH
 440                                  && (addr2info(dest) == NULL)
 441 #endif
 442            ){
 443                 int rc;
 444                 rc = read_dataflash(addr, count * size, (char *) dest);
 445                 if (rc != 1) {
 446                         dataflash_perror (rc);
 447                         return (1);
 448                 }
 449                 return 0;
 450         }
 451
 452         if (addr_dataflash(addr) && addr_dataflash(dest)){
 453                 puts ("Unsupported combination of source/destination.\n\r");
 454                 return 1;
 455         }
 456 #endif
 457
 458 #ifdef CONFIG_BLACKFIN
 459         /* See if we're copying to/from L1 inst */
 460         if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) {
 461                 memcpy((void *)dest, (void *)addr, count * size);
 462                 return 0;
 463         }
 464 #endif
 465
 466         memcpy((void *)dest, (void *)addr, count * size);
 467
 468         return 0;
 469 }
 470
 471 static int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
 472                        char * const argv[])
 473 {
 474         if (argc > 1) {
 475                 /* Set new base address.
 476                 */
 477                 base_address = simple_strtoul(argv[1], NULL, 16);
 478         }
 479         /* Print the current base address.
 480         */
 481         printf("Base Address: 0x%08lx\n", base_address);
 482         return 0;
 483 }
 484
 485 static int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
 486                        char * const argv[])
 487 {
 488         ulong   addr, length, i, bytes;
 489         int     size;
 490 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
 491         volatile u64 *llp;
 492 #endif
 493         volatile u32 *longp;
 494         volatile u16 *shortp;
 495         volatile u8 *cp;
 496         const void *buf;
 497
 498         if (argc < 3)
 499                 return CMD_RET_USAGE;
 500
 501         /*
 502          * Check for a size specification.
 503          * Defaults to long if no or incorrect specification.
 504          */
 505         if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 506                 return 1;
 507
 508         /* Address is always specified.
 509         */
 510         addr = simple_strtoul(argv[1], NULL, 16);
 511
 512         /* Length is the number of objects, not number of bytes.
 513         */
 514         length = simple_strtoul(argv[2], NULL, 16);
 515
 516         bytes = size * length;
 517         buf = map_sysmem(addr, bytes);
 518
 519         /* We want to optimize the loops to run as fast as possible.
 520          * If we have only one object, just run infinite loops.
 521          */
 522         if (length == 1) {
 523 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
 524                 if (size == 8) {
 525                         llp = (u64 *)buf;
 526                         for (;;)
 527                                 i = *llp;
 528                 }
 529 #endif
 530                 if (size == 4) {
 531                         longp = (u32 *)buf;
 532                         for (;;)
 533                                 i = *longp;
 534                 }
 535                 if (size == 2) {
 536                         shortp = (u16 *)buf;
 537                         for (;;)
 538                                 i = *shortp;
 539                 }
 540                 cp = (u8 *)buf;
 541                 for (;;)
 542                         i = *cp;
 543         }
 544
 545 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
 546         if (size == 8) {
 547                 for (;;) {
 548                         llp = (u64 *)buf;
 549                         i = length;
 550                         while (i-- > 0)
 551                                 *llp++;
 552                 }
 553         }
 554 #endif
 555         if (size == 4) {
 556                 for (;;) {
 557                         longp = (u32 *)buf;
 558                         i = length;
 559                         while (i-- > 0)
 560                                 *longp++;
 561                 }
 562         }
 563         if (size == 2) {
 564                 for (;;) {
 565                         shortp = (u16 *)buf;
 566                         i = length;
 567                         while (i-- > 0)
 568                                 *shortp++;
 569                 }
 570         }
 571         for (;;) {
 572                 cp = (u8 *)buf;
 573                 i = length;
 574                 while (i-- > 0)
 575                         *cp++;
 576         }
 577         unmap_sysmem(buf);
 578
 579         return 0;
 580 }
 581
 582 #ifdef CONFIG_LOOPW
 583 static int do_mem_loopw(cmd_tbl_t *cmdtp, int flag, int argc,
 584                         char * const argv[])
 585 {
 586         ulong   addr, length, i, bytes;
 587         int     size;
 588 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
 589         volatile u64 *llp;
 590         u64 data;
 591 #else
 592         ulong   data;
 593 #endif
 594         volatile u32 *longp;
 595         volatile u16 *shortp;
 596         volatile u8 *cp;
 597         void *buf;
 598
 599         if (argc < 4)
 600                 return CMD_RET_USAGE;
 601
 602         /*
 603          * Check for a size specification.
 604          * Defaults to long if no or incorrect specification.
 605          */
 606         if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 607                 return 1;
 608
 609         /* Address is always specified.
 610         */
 611         addr = simple_strtoul(argv[1], NULL, 16);
 612
 613         /* Length is the number of objects, not number of bytes.
 614         */
 615         length = simple_strtoul(argv[2], NULL, 16);
 616
 617         /* data to write */
 618 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
 619         data = simple_strtoull(argv[3], NULL, 16);
 620 #else
 621         data = simple_strtoul(argv[3], NULL, 16);
 622 #endif
 623
 624         bytes = size * length;
 625         buf = map_sysmem(addr, bytes);
 626
 627         /* We want to optimize the loops to run as fast as possible.
 628          * If we have only one object, just run infinite loops.
 629          */
 630         if (length == 1) {
 631 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
 632                 if (size == 8) {
 633                         llp = (u64 *)buf;
 634                         for (;;)
 635                                 *llp = data;
 636                 }
 637 #endif
 638                 if (size == 4) {
 639                         longp = (u32 *)buf;
 640                         for (;;)
 641                                 *longp = data;
 642                 }
 643                 if (size == 2) {
 644                         shortp = (u16 *)buf;
 645                         for (;;)
 646                                 *shortp = data;
 647                 }
 648                 cp = (u8 *)buf;
 649                 for (;;)
 650                         *cp = data;
 651         }
 652
 653 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
 654         if (size == 8) {
 655                 for (;;) {
 656                         llp = (u64 *)buf;
 657                         i = length;
 658                         while (i-- > 0)
 659                                 *llp++ = data;
 660                 }
 661         }
 662 #endif
 663         if (size == 4) {
 664                 for (;;) {
 665                         longp = (u32 *)buf;
 666                         i = length;
 667                         while (i-- > 0)
 668                                 *longp++ = data;
 669                 }
 670         }
 671         if (size == 2) {
 672                 for (;;) {
 673                         shortp = (u16 *)buf;
 674                         i = length;
 675                         while (i-- > 0)
 676                                 *shortp++ = data;
 677                 }
 678         }
 679         for (;;) {
 680                 cp = (u8 *)buf;
 681                 i = length;
 682                 while (i-- > 0)
 683                         *cp++ = data;
 684         }
 685 }
 686 #endif /* CONFIG_LOOPW */
 687
 688 #ifdef CONFIG_CMD_MEMTEST
 689 static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
 690                           vu_long *dummy)
 691 {
 692         vu_long *addr;
 693         ulong errs = 0;
 694         ulong val, readback;
 695         int j;
 696         vu_long offset;
 697         vu_long test_offset;
 698         vu_long pattern;
 699         vu_long temp;
 700         vu_long anti_pattern;
 701         vu_long num_words;
 702         static const ulong bitpattern[] = {
 703                 0x00000001,     /* single bit */
 704                 0x00000003,     /* two adjacent bits */
 705                 0x00000007,     /* three adjacent bits */
 706                 0x0000000F,     /* four adjacent bits */
 707                 0x00000005,     /* two non-adjacent bits */
 708                 0x00000015,     /* three non-adjacent bits */
 709                 0x00000055,     /* four non-adjacent bits */
 710                 0xaaaaaaaa,     /* alternating 1/0 */
 711         };
 712
 713         num_words = (end_addr - start_addr) / sizeof(vu_long);
 714
 715         /*
 716          * Data line test: write a pattern to the first
 717          * location, write the 1's complement to a 'parking'
 718          * address (changes the state of the data bus so a
 719          * floating bus doesn't give a false OK), and then
 720          * read the value back. Note that we read it back
 721          * into a variable because the next time we read it,
 722          * it might be right (been there, tough to explain to
 723          * the quality guys why it prints a failure when the
 724          * "is" and "should be" are obviously the same in the
 725          * error message).
 726          *
 727          * Rather than exhaustively testing, we test some
 728          * patterns by shifting '1' bits through a field of
 729          * '0's and '0' bits through a field of '1's (i.e.
 730          * pattern and ~pattern).
 731          */
 732         addr = buf;
 733         for (j = 0; j < sizeof(bitpattern) / sizeof(bitpattern[0]); j++) {
 734                 val = bitpattern[j];
 735                 for (; val != 0; val <<= 1) {
 736                         *addr = val;
 737                         *dummy  = ~val; /* clear the test data off the bus */
 738                         readback = *addr;
 739                         if (readback != val) {
 740                                 printf("FAILURE (data line): "
 741                                         "expected %08lx, actual %08lx\n",
 742                                                 val, readback);
 743                                 errs++;
 744                                 if (ctrlc())
 745                                         return -1;
 746                         }
 747                         *addr  = ~val;
 748                         *dummy  = val;
 749                         readback = *addr;
 750                         if (readback != ~val) {
 751                                 printf("FAILURE (data line): "
 752                                         "Is %08lx, should be %08lx\n",
 753                                                 readback, ~val);
 754                                 errs++;
 755                                 if (ctrlc())
 756                                         return -1;
 757                         }
 758                 }
 759         }
 760
 761         /*
 762          * Based on code whose Original Author and Copyright
 763          * information follows: Copyright (c) 1998 by Michael
 764          * Barr. This software is placed into the public
 765          * domain and may be used for any purpose. However,
 766          * this notice must not be changed or removed and no
 767          * warranty is either expressed or implied by its
 768          * publication or distribution.
 769          */
 770
 771         /*
 772         * Address line test
 773
 774          * Description: Test the address bus wiring in a
 775          *              memory region by performing a walking
 776          *              1's test on the relevant bits of the
 777          *              address and checking for aliasing.
 778          *              This test will find single-bit
 779          *              address failures such as stuck-high,
 780          *              stuck-low, and shorted pins. The base
 781          *              address and size of the region are
 782          *              selected by the caller.
 783
 784          * Notes:       For best results, the selected base
 785          *              address should have enough LSB 0's to
 786          *              guarantee single address bit changes.
 787          *              For example, to test a 64-Kbyte
 788          *              region, select a base address on a
 789          *              64-Kbyte boundary. Also, select the
 790          *              region size as a power-of-two if at
 791          *              all possible.
 792          *
 793          * Returns:     0 if the test succeeds, 1 if the test fails.
 794          */
 795         pattern = (vu_long) 0xaaaaaaaa;
 796         anti_pattern = (vu_long) 0x55555555;
 797
 798         debug("%s:%d: length = 0x%.8lx\n", __func__, __LINE__, num_words);
 799         /*
 800          * Write the default pattern at each of the
 801          * power-of-two offsets.
 802          */
 803         for (offset = 1; offset < num_words; offset <<= 1)
 804                 addr[offset] = pattern;
 805
 806         /*
 807          * Check for address bits stuck high.
 808          */
 809         test_offset = 0;
 810         addr[test_offset] = anti_pattern;
 811
 812         for (offset = 1; offset < num_words; offset <<= 1) {
 813                 temp = addr[offset];
 814                 if (temp != pattern) {
 815                         printf("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
 816                                 " expected 0x%.8lx, actual 0x%.8lx\n",
 817                                 start_addr + offset*sizeof(vu_long),
 818                                 pattern, temp);
 819                         errs++;
 820                         if (ctrlc())
 821                                 return -1;
 822                 }
 823         }
 824         addr[test_offset] = pattern;
 825         WATCHDOG_RESET();
 826
 827         /*
 828          * Check for addr bits stuck low or shorted.
 829          */
 830         for (test_offset = 1; test_offset < num_words; test_offset <<= 1) {
 831                 addr[test_offset] = anti_pattern;
 832
 833                 for (offset = 1; offset < num_words; offset <<= 1) {
 834                         temp = addr[offset];
 835                         if ((temp != pattern) && (offset != test_offset)) {
 836                                 printf("\nFAILURE: Address bit stuck low or"
 837                                         " shorted @ 0x%.8lx: expected 0x%.8lx,"
 838                                         " actual 0x%.8lx\n",
 839                                         start_addr + offset*sizeof(vu_long),
 840                                         pattern, temp);
 841                                 errs++;
 842                                 if (ctrlc())
 843                                         return -1;
 844                         }
 845                 }
 846                 addr[test_offset] = pattern;
 847         }
 848
 849         /*
 850          * Description: Test the integrity of a physical
 851          *              memory device by performing an
 852          *              increment/decrement test over the
 853          *              entire region. In the process every
 854          *              storage bit in the device is tested
 855          *              as a zero and a one. The base address
 856          *              and the size of the region are
 857          *              selected by the caller.
 858          *
 859          * Returns:     0 if the test succeeds, 1 if the test fails.
 860          */
 861         num_words++;
 862
 863         /*
 864          * Fill memory with a known pattern.
 865          */
 866         for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
 867                 WATCHDOG_RESET();
 868                 addr[offset] = pattern;
 869         }
 870
 871         /*
 872          * Check each location and invert it for the second pass.
 873          */
 874         for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
 875                 WATCHDOG_RESET();
 876                 temp = addr[offset];
 877                 if (temp != pattern) {
 878                         printf("\nFAILURE (read/write) @ 0x%.8lx:"
 879                                 " expected 0x%.8lx, actual 0x%.8lx)\n",
 880                                 start_addr + offset*sizeof(vu_long),
 881                                 pattern, temp);
 882                         errs++;
 883                         if (ctrlc())
 884                                 return -1;
 885                 }
 886
 887                 anti_pattern = ~pattern;
 888                 addr[offset] = anti_pattern;
 889         }
 890
 891         /*
 892          * Check each location for the inverted pattern and zero it.
 893          */
 894         for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
 895                 WATCHDOG_RESET();
 896                 anti_pattern = ~pattern;
 897                 temp = addr[offset];
 898                 if (temp != anti_pattern) {
 899                         printf("\nFAILURE (read/write): @ 0x%.8lx:"
 900                                 " expected 0x%.8lx, actual 0x%.8lx)\n",
 901                                 start_addr + offset*sizeof(vu_long),
 902                                 anti_pattern, temp);
 903                         errs++;
 904                         if (ctrlc())
 905                                 return -1;
 906                 }
 907                 addr[offset] = 0;
 908         }
 909
 910         return errs;
 911 }
 912
 913 static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
 914                             vu_long pattern, int iteration)
 915 {
 916         vu_long *end;
 917         vu_long *addr;
 918         ulong errs = 0;
 919         ulong incr, length;
 920         ulong val, readback;
 921
 922         /* Alternate the pattern */
 923         incr = 1;
 924         if (iteration & 1) {
 925                 incr = -incr;
 926                 /*
 927                  * Flip the pattern each time to make lots of zeros and
 928                  * then, the next time, lots of ones.  We decrement
 929                  * the "negative" patterns and increment the "positive"
 930                  * patterns to preserve this feature.
 931                  */
 932                 if (pattern & 0x80000000)
 933                         pattern = -pattern;     /* complement & increment */
 934                 else
 935                         pattern = ~pattern;
 936         }
 937         length = (end_addr - start_addr) / sizeof(ulong);
 938         end = buf + length;
 939         printf("\rPattern %08lX  Writing..."
 940                 "%12s"
 941                 "\b\b\b\b\b\b\b\b\b\b",
 942                 pattern, "");
 943
 944         for (addr = buf, val = pattern; addr < end; addr++) {
 945                 WATCHDOG_RESET();
 946                 *addr = val;
 947                 val += incr;
 948         }
 949
 950         puts("Reading...");
 951
 952         for (addr = buf, val = pattern; addr < end; addr++) {
 953                 WATCHDOG_RESET();
 954                 readback = *addr;
 955                 if (readback != val) {
 956                         ulong offset = addr - buf;
 957
 958                         printf("\nMem error @ 0x%08X: "
 959                                 "found %08lX, expected %08lX\n",
 960                                 (uint)(uintptr_t)(start_addr + offset*sizeof(vu_long)),
 961                                 readback, val);
 962                         errs++;
 963                         if (ctrlc())
 964                                 return -1;
 965                 }
 966                 val += incr;
 967         }
 968
 969         return errs;
 970 }
 971
 972 /*
 973  * Perform a memory test. A more complete alternative test can be
 974  * configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
 975  * interrupted by ctrl-c or by a failure of one of the sub-tests.
 976  */
 977 static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
 978                         char * const argv[])
 979 {
 980         ulong start, end;
 981         vu_long *buf, *dummy;
 982         ulong iteration_limit = 0;
 983         int ret;
 984         ulong errs = 0; /* number of errors, or -1 if interrupted */
 985         ulong pattern = 0;
 986         int iteration;
 987 #if defined(CONFIG_SYS_ALT_MEMTEST)
 988         const int alt_test = 1;
 989 #else
 990         const int alt_test = 0;
 991 #endif
 992
 993         start = CONFIG_SYS_MEMTEST_START;
 994         end = CONFIG_SYS_MEMTEST_END;
 995
 996         if (argc > 1)
 997                 if (strict_strtoul(argv[1], 16, &start) < 0)
 998                         return CMD_RET_USAGE;
 999
1000         if (argc > 2)
1001                 if (strict_strtoul(argv[2], 16, &end) < 0)
1002                         return CMD_RET_USAGE;
1003
1004         if (argc > 3)
1005                 if (strict_strtoul(argv[3], 16, &pattern) < 0)
1006                         return CMD_RET_USAGE;
1007
1008         if (argc > 4)
1009                 if (strict_strtoul(argv[4], 16, &iteration_limit) < 0)
1010                         return CMD_RET_USAGE;
1011
1012         if (end < start) {
1013                 printf("Refusing to do empty test\n");
1014                 return -1;
1015         }
1016
1017         printf("Testing %08lx ... %08lx:\n", start, end);
1018         debug("%s:%d: start %#08lx end %#08lx\n", __func__, __LINE__,
1019               start, end);
1020
1021         buf = map_sysmem(start, end - start);
1022         dummy = map_sysmem(CONFIG_SYS_MEMTEST_SCRATCH, sizeof(vu_long));
1023         for (iteration = 0;
1024                         !iteration_limit || iteration < iteration_limit;
1025                         iteration++) {
1026                 if (ctrlc()) {
1027                         errs = -1UL;
1028                         break;
1029                 }
1030
1031                 printf("Iteration: %6d\r", iteration + 1);
1032                 debug("\n");
1033                 if (alt_test) {
1034                         errs = mem_test_alt(buf, start, end, dummy);
1035                 } else {
1036                         errs = mem_test_quick(buf, start, end, pattern,
1037                                               iteration);
1038                 }
1039                 if (errs == -1UL)
1040                         break;
1041         }
1042
1043         /*
1044          * Work-around for eldk-4.2 which gives this warning if we try to
1045          * case in the unmap_sysmem() call:
1046          * warning: initialization discards qualifiers from pointer target type
1047          */
1048         {
1049                 void *vbuf = (void *)buf;
1050                 void *vdummy = (void *)dummy;
1051
1052                 unmap_sysmem(vbuf);
1053                 unmap_sysmem(vdummy);
1054         }
1055
1056         if (errs == -1UL) {
1057                 /* Memory test was aborted - write a newline to finish off */
1058                 putc('\n');
1059                 ret = 1;
1060         } else {
1061                 printf("Tested %d iteration(s) with %lu errors.\n",
1062                         iteration, errs);
1063                 ret = errs != 0;
1064         }
1065
1066         return ret;
1067 }
1068 #endif  /* CONFIG_CMD_MEMTEST */
1069
1070 /* Modify memory.
1071  *
1072  * Syntax:
1073  *      mm{.b, .w, .l, .q} {addr}
1074  *      nm{.b, .w, .l, .q} {addr}
1075  */
1076 static int
1077 mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
1078 {
1079         ulong   addr;
1080 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1081         u64 i;
1082 #else
1083         ulong i;
1084 #endif
1085         int     nbytes, size;
1086         void *ptr = NULL;
1087
1088         if (argc != 2)
1089                 return CMD_RET_USAGE;
1090
1091         bootretry_reset_cmd_timeout();  /* got a good command to get here */
1092         /* We use the last specified parameters, unless new ones are
1093          * entered.
1094          */
1095         addr = mm_last_addr;
1096         size = mm_last_size;
1097
1098         if ((flag & CMD_FLAG_REPEAT) == 0) {
1099                 /* New command specified.  Check for a size specification.
1100                  * Defaults to long if no or incorrect specification.
1101                  */
1102                 if ((size = cmd_get_data_size(argv[0], 4)) < 0)
1103                         return 1;
1104
1105                 /* Address is specified since argc > 1
1106                 */
1107                 addr = simple_strtoul(argv[1], NULL, 16);
1108                 addr += base_address;
1109         }
1110
1111 #ifdef CONFIG_HAS_DATAFLASH
1112         if (addr_dataflash(addr)){
1113                 puts ("Can't modify DataFlash in place. Use cp instead.\n\r");
1114                 return 0;
1115         }
1116 #endif
1117
1118 #ifdef CONFIG_BLACKFIN
1119         if (addr_bfin_on_chip_mem(addr)) {
1120                 puts ("Can't modify L1 instruction in place. Use cp instead.\n\r");
1121                 return 0;
1122         }
1123 #endif
1124
1125         /* Print the address, followed by value.  Then accept input for
1126          * the next value.  A non-converted value exits.
1127          */
1128         do {
1129                 ptr = map_sysmem(addr, size);
1130                 printf("%08lx:", addr);
1131                 if (size == 4)
1132                         printf(" %08x", *((u32 *)ptr));
1133 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1134                 else if (size == 8)
1135                         printf(" %016" PRIx64, *((u64 *)ptr));
1136 #endif
1137                 else if (size == 2)
1138                         printf(" %04x", *((u16 *)ptr));
1139                 else
1140                         printf(" %02x", *((u8 *)ptr));
1141
1142                 nbytes = cli_readline(" ? ");
1143                 if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
1144                         /* <CR> pressed as only input, don't modify current
1145                          * location and move to next. "-" pressed will go back.
1146                          */
1147                         if (incrflag)
1148                                 addr += nbytes ? -size : size;
1149                         nbytes = 1;
1150                         /* good enough to not time out */
1151                         bootretry_reset_cmd_timeout();
1152                 }
1153 #ifdef CONFIG_BOOT_RETRY_TIME
1154                 else if (nbytes == -2) {
1155                         break;  /* timed out, exit the command  */
1156                 }
1157 #endif
1158                 else {
1159                         char *endp;
1160 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1161                         i = simple_strtoull(console_buffer, &endp, 16);
1162 #else
1163                         i = simple_strtoul(console_buffer, &endp, 16);
1164 #endif
1165                         nbytes = endp - console_buffer;
1166                         if (nbytes) {
1167                                 /* good enough to not time out
1168                                  */
1169                                 bootretry_reset_cmd_timeout();
1170                                 if (size == 4)
1171                                         *((u32 *)ptr) = i;
1172 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1173                                 else if (size == 8)
1174                                         *((u64 *)ptr) = i;
1175 #endif
1176                                 else if (size == 2)
1177                                         *((u16 *)ptr) = i;
1178                                 else
1179                                         *((u8 *)ptr) = i;
1180                                 if (incrflag)
1181                                         addr += size;
1182                         }
1183                 }
1184         } while (nbytes);
1185         if (ptr)
1186                 unmap_sysmem(ptr);
1187
1188         mm_last_addr = addr;
1189         mm_last_size = size;
1190         return 0;
1191 }
1192
1193 #ifdef CONFIG_CMD_CRC32
1194
1195 static int do_mem_crc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1196 {
1197         int flags = 0;
1198         int ac;
1199         char * const *av;
1200
1201         if (argc < 3)
1202                 return CMD_RET_USAGE;
1203
1204         av = argv + 1;
1205         ac = argc - 1;
1206 #ifdef CONFIG_HASH_VERIFY
1207         if (strcmp(*av, "-v") == 0) {
1208                 flags |= HASH_FLAG_VERIFY | HASH_FLAG_ENV;
1209                 av++;
1210                 ac--;
1211         }
1212 #endif
1213
1214         return hash_command("crc32", flags, cmdtp, flag, ac, av);
1215 }
1216
1217 #endif
1218
1219 /**************************************************/
1220 U_BOOT_CMD(
1221         md,     3,      1,      do_mem_md,
1222         "memory display",
1223 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1224         "[.b, .w, .l, .q] address [# of objects]"
1225 #else
1226         "[.b, .w, .l] address [# of objects]"
1227 #endif
1228 );
1229
1230
1231 U_BOOT_CMD(
1232         mm,     2,      1,      do_mem_mm,
1233         "memory modify (auto-incrementing address)",
1234 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1235         "[.b, .w, .l, .q] address"
1236 #else
1237         "[.b, .w, .l] address"
1238 #endif
1239 );
1240
1241
1242 U_BOOT_CMD(
1243         nm,     2,      1,      do_mem_nm,
1244         "memory modify (constant address)",
1245 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1246         "[.b, .w, .l, .q] address"
1247 #else
1248         "[.b, .w, .l] address"
1249 #endif
1250 );
1251
1252 U_BOOT_CMD(
1253         mw,     4,      1,      do_mem_mw,
1254         "memory write (fill)",
1255 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1256         "[.b, .w, .l, .q] address value [count]"
1257 #else
1258         "[.b, .w, .l] address value [count]"
1259 #endif
1260 );
1261
1262 U_BOOT_CMD(
1263         cp,     4,      1,      do_mem_cp,
1264         "memory copy",
1265 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1266         "[.b, .w, .l, .q] source target count"
1267 #else
1268         "[.b, .w, .l] source target count"
1269 #endif
1270 );
1271
1272 U_BOOT_CMD(
1273         cmp,    4,      1,      do_mem_cmp,
1274         "memory compare",
1275 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1276         "[.b, .w, .l, .q] addr1 addr2 count"
1277 #else
1278         "[.b, .w, .l] addr1 addr2 count"
1279 #endif
1280 );
1281
1282 #ifdef CONFIG_CMD_CRC32
1283
1284 #ifndef CONFIG_HASH_VERIFY
1285
1286 U_BOOT_CMD(
1287         crc32,  4,      1,      do_mem_crc,
1288         "checksum calculation",
1289         "address count [addr]\n    - compute CRC32 checksum [save at addr]"
1290 );
1291
1292 #else   /* CONFIG_HASH_VERIFY */
1293
1294 U_BOOT_CMD(
1295         crc32,  5,      1,      do_mem_crc,
1296         "checksum calculation",
1297         "address count [addr]\n    - compute CRC32 checksum [save at addr]\n"
1298         "-v address count crc\n    - verify crc of memory area"
1299 );
1300
1301 #endif  /* CONFIG_HASH_VERIFY */
1302
1303 #endif
1304
1305 #ifdef CONFIG_CMD_MEMINFO
1306 __weak void board_show_dram(phys_size_t size)
1307 {
1308         puts("DRAM:  ");
1309         print_size(size, "\n");
1310 }
1311
1312 static int do_mem_info(cmd_tbl_t *cmdtp, int flag, int argc,
1313                        char * const argv[])
1314 {
1315         board_show_dram(gd->ram_size);
1316
1317         return 0;
1318 }
1319 #endif
1320
1321 U_BOOT_CMD(
1322         base,   2,      1,      do_mem_base,
1323         "print or set address offset",
1324         "\n    - print address offset for memory commands\n"
1325         "base off\n    - set address offset for memory commands to 'off'"
1326 );
1327
1328 U_BOOT_CMD(
1329         loop,   3,      1,      do_mem_loop,
1330         "infinite loop on address range",
1331 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1332         "[.b, .w, .l, .q] address number_of_objects"
1333 #else
1334         "[.b, .w, .l] address number_of_objects"
1335 #endif
1336 );
1337
1338 #ifdef CONFIG_LOOPW
1339 U_BOOT_CMD(
1340         loopw,  4,      1,      do_mem_loopw,
1341         "infinite write loop on address range",
1342 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1343         "[.b, .w, .l, .q] address number_of_objects data_to_write"
1344 #else
1345         "[.b, .w, .l] address number_of_objects data_to_write"
1346 #endif
1347 );
1348 #endif /* CONFIG_LOOPW */
1349
1350 #ifdef CONFIG_CMD_MEMTEST
1351 U_BOOT_CMD(
1352         mtest,  5,      1,      do_mem_mtest,
1353         "simple RAM read/write test",
1354         "[start [end [pattern [iterations]]]]"
1355 );
1356 #endif  /* CONFIG_CMD_MEMTEST */
1357
1358 #ifdef CONFIG_MX_CYCLIC
1359 U_BOOT_CMD(
1360         mdc,    4,      1,      do_mem_mdc,
1361         "memory display cyclic",
1362 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1363         "[.b, .w, .l, .q] address count delay(ms)"
1364 #else
1365         "[.b, .w, .l] address count delay(ms)"
1366 #endif
1367 );
1368
1369 U_BOOT_CMD(
1370         mwc,    4,      1,      do_mem_mwc,
1371         "memory write cyclic",
1372 #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
1373         "[.b, .w, .l, .q] address value delay(ms)"
1374 #else
1375         "[.b, .w, .l] address value delay(ms)"
1376 #endif
1377 );
1378 #endif /* CONFIG_MX_CYCLIC */
1379
1380 #ifdef CONFIG_CMD_MEMINFO
1381 U_BOOT_CMD(
1382         meminfo,        3,      1,      do_mem_info,
1383         "display memory information",
1384         ""
1385 );
1386 #endif