common/cmd_mem.c

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