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