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