common/cmd_mem.c

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