cmd/mem.c

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