common/cmd_mem.c

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