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