1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2007 4 * Gerald Van Baren, Custom IDEAS, vanbaren (at) cideas.com 5 * Based on code written by: 6 * Pantelis Antoniou <pantelis.antoniou (at) gmail.com> and 7 * Matthew McClintock <msm (at) freescale.com> 8 */ 9 10 #include <common.h> 11 #include <command.h> 12 #include <linux/ctype.h> 13 #include <linux/types.h> 14 #include <asm/global_data.h> 15 #include <linux/libfdt.h> 16 #include <fdt_support.h> 17 #include <mapmem.h> 18 #include <asm/io.h> 19 20 #define MAX_LEVEL 32 /* how deeply nested we will go */ 21 #define SCRATCHPAD 1024 /* bytes of scratchpad memory */ 22 #define CMD_FDT_MAX_DUMP 64 23 24 /* 25 * Global data (for the gd->bd) 26 */ 27 DECLARE_GLOBAL_DATA_PTR; 28 29 static int fdt_valid(struct fdt_header **blobp); 30 static int fdt_parse_prop(char *const*newval, int count, char *data, int *len); 31 static int fdt_print(const char *pathp, char *prop, int depth); 32 static int is_printable_string(const void *data, int len); 33 34 /* 35 * The working_fdt points to our working flattened device tree. 36 */ 37 struct fdt_header *working_fdt; 38 39 void set_working_fdt_addr(ulong addr) 40 { 41 void *buf; 42 43 buf = map_sysmem(addr, 0); 44 working_fdt = buf; 45 env_set_hex("fdtaddr", addr); 46 } 47 48 /* 49 * Get a value from the fdt and format it to be set in the environment 50 */ 51 static int fdt_value_env_set(const void *nodep, int len, const char *var) 52 { 53 if (is_printable_string(nodep, len)) 54 env_set(var, (void *)nodep); 55 else if (len == 4) { 56 char buf[11]; 57 58 sprintf(buf, "0x%08X", fdt32_to_cpu(*(fdt32_t *)nodep)); 59 env_set(var, buf); 60 } else if (len%4 == 0 && len <= 20) { 61 /* Needed to print things like sha1 hashes. */ 62 char buf[41]; 63 int i; 64 65 for (i = 0; i < len; i += sizeof(unsigned int)) 66 sprintf(buf + (i * 2), "%08x", 67 *(unsigned int *)(nodep + i)); 68 env_set(var, buf); 69 } else { 70 printf("error: unprintable value\n"); 71 return 1; 72 } 73 return 0; 74 } 75 76 /* 77 * Flattened Device Tree command, see the help for parameter definitions. 78 */ 79 static int do_fdt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 80 { 81 if (argc < 2) 82 return CMD_RET_USAGE; 83 84 /* 85 * Set the address of the fdt 86 */ 87 if (strncmp(argv[1], "ad", 2) == 0) { 88 unsigned long addr; 89 int control = 0; 90 struct fdt_header *blob; 91 /* 92 * Set the address [and length] of the fdt. 93 */ 94 argc -= 2; 95 argv += 2; 96 /* Temporary #ifdef - some archs don't have fdt_blob yet */ 97 #ifdef CONFIG_OF_CONTROL 98 if (argc && !strcmp(*argv, "-c")) { 99 control = 1; 100 argc--; 101 argv++; 102 } 103 #endif 104 if (argc == 0) { 105 if (control) 106 blob = (struct fdt_header *)gd->fdt_blob; 107 else 108 blob = working_fdt; 109 if (!blob || !fdt_valid(&blob)) 110 return 1; 111 printf("The address of the fdt is %#08lx\n", 112 control ? (ulong)map_to_sysmem(blob) : 113 env_get_hex("fdtaddr", 0)); 114 return 0; 115 } 116 117 addr = simple_strtoul(argv[0], NULL, 16); 118 blob = map_sysmem(addr, 0); 119 if (!fdt_valid(&blob)) 120 return 1; 121 if (control) 122 gd->fdt_blob = blob; 123 else 124 set_working_fdt_addr(addr); 125 126 if (argc >= 2) { 127 int len; 128 int err; 129 /* 130 * Optional new length 131 */ 132 len = simple_strtoul(argv[1], NULL, 16); 133 if (len < fdt_totalsize(blob)) { 134 printf ("New length %d < existing length %d, " 135 "ignoring.\n", 136 len, fdt_totalsize(blob)); 137 } else { 138 /* 139 * Open in place with a new length. 140 */ 141 err = fdt_open_into(blob, blob, len); 142 if (err != 0) { 143 printf ("libfdt fdt_open_into(): %s\n", 144 fdt_strerror(err)); 145 } 146 } 147 } 148 149 return CMD_RET_SUCCESS; 150 } 151 152 if (!working_fdt) { 153 puts( 154 "No FDT memory address configured. Please configure\n" 155 "the FDT address via \"fdt addr <address>\" command.\n" 156 "Aborting!\n"); 157 return CMD_RET_FAILURE; 158 } 159 160 /* 161 * Move the working_fdt 162 */ 163 if (strncmp(argv[1], "mo", 2) == 0) { 164 struct fdt_header *newaddr; 165 int len; 166 int err; 167 168 if (argc < 4) 169 return CMD_RET_USAGE; 170 171 /* 172 * Set the address and length of the fdt. 173 */ 174 working_fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16); 175 if (!fdt_valid(&working_fdt)) 176 return 1; 177 178 newaddr = (struct fdt_header *)simple_strtoul(argv[3],NULL,16); 179 180 /* 181 * If the user specifies a length, use that. Otherwise use the 182 * current length. 183 */ 184 if (argc <= 4) { 185 len = fdt_totalsize(working_fdt); 186 } else { 187 len = simple_strtoul(argv[4], NULL, 16); 188 if (len < fdt_totalsize(working_fdt)) { 189 printf ("New length 0x%X < existing length " 190 "0x%X, aborting.\n", 191 len, fdt_totalsize(working_fdt)); 192 return 1; 193 } 194 } 195 196 /* 197 * Copy to the new location. 198 */ 199 err = fdt_open_into(working_fdt, newaddr, len); 200 if (err != 0) { 201 printf ("libfdt fdt_open_into(): %s\n", 202 fdt_strerror(err)); 203 return 1; 204 } 205 working_fdt = newaddr; 206 #ifdef CONFIG_OF_SYSTEM_SETUP 207 /* Call the board-specific fixup routine */ 208 } else if (strncmp(argv[1], "sys", 3) == 0) { 209 int err = ft_system_setup(working_fdt, gd->bd); 210 211 if (err) { 212 printf("Failed to add system information to FDT: %s\n", 213 fdt_strerror(err)); 214 return CMD_RET_FAILURE; 215 } 216 #endif 217 /* 218 * Make a new node 219 */ 220 } else if (strncmp(argv[1], "mk", 2) == 0) { 221 char *pathp; /* path */ 222 char *nodep; /* new node to add */ 223 int nodeoffset; /* node offset from libfdt */ 224 int err; 225 226 /* 227 * Parameters: Node path, new node to be appended to the path. 228 */ 229 if (argc < 4) 230 return CMD_RET_USAGE; 231 232 pathp = argv[2]; 233 nodep = argv[3]; 234 235 nodeoffset = fdt_path_offset (working_fdt, pathp); 236 if (nodeoffset < 0) { 237 /* 238 * Not found or something else bad happened. 239 */ 240 printf ("libfdt fdt_path_offset() returned %s\n", 241 fdt_strerror(nodeoffset)); 242 return 1; 243 } 244 err = fdt_add_subnode(working_fdt, nodeoffset, nodep); 245 if (err < 0) { 246 printf ("libfdt fdt_add_subnode(): %s\n", 247 fdt_strerror(err)); 248 return 1; 249 } 250 251 /* 252 * Set the value of a property in the working_fdt. 253 */ 254 } else if (argv[1][0] == 's') { 255 char *pathp; /* path */ 256 char *prop; /* property */ 257 int nodeoffset; /* node offset from libfdt */ 258 static char data[SCRATCHPAD] __aligned(4);/* property storage */ 259 const void *ptmp; 260 int len; /* new length of the property */ 261 int ret; /* return value */ 262 263 /* 264 * Parameters: Node path, property, optional value. 265 */ 266 if (argc < 4) 267 return CMD_RET_USAGE; 268 269 pathp = argv[2]; 270 prop = argv[3]; 271 272 nodeoffset = fdt_path_offset (working_fdt, pathp); 273 if (nodeoffset < 0) { 274 /* 275 * Not found or something else bad happened. 276 */ 277 printf ("libfdt fdt_path_offset() returned %s\n", 278 fdt_strerror(nodeoffset)); 279 return 1; 280 } 281 282 if (argc == 4) { 283 len = 0; 284 } else { 285 ptmp = fdt_getprop(working_fdt, nodeoffset, prop, &len); 286 if (len > SCRATCHPAD) { 287 printf("prop (%d) doesn't fit in scratchpad!\n", 288 len); 289 return 1; 290 } 291 if (ptmp != NULL) 292 memcpy(data, ptmp, len); 293 294 ret = fdt_parse_prop(&argv[4], argc - 4, data, &len); 295 if (ret != 0) 296 return ret; 297 } 298 299 ret = fdt_setprop(working_fdt, nodeoffset, prop, data, len); 300 if (ret < 0) { 301 printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret)); 302 return 1; 303 } 304 305 /******************************************************************** 306 * Get the value of a property in the working_fdt. 307 ********************************************************************/ 308 } else if (argv[1][0] == 'g') { 309 char *subcmd; /* sub-command */ 310 char *pathp; /* path */ 311 char *prop; /* property */ 312 char *var; /* variable to store result */ 313 int nodeoffset; /* node offset from libfdt */ 314 const void *nodep; /* property node pointer */ 315 int len = 0; /* new length of the property */ 316 317 /* 318 * Parameters: Node path, property, optional value. 319 */ 320 if (argc < 5) 321 return CMD_RET_USAGE; 322 323 subcmd = argv[2]; 324 325 if (argc < 6 && subcmd[0] != 's') 326 return CMD_RET_USAGE; 327 328 var = argv[3]; 329 pathp = argv[4]; 330 prop = argv[5]; 331 332 nodeoffset = fdt_path_offset(working_fdt, pathp); 333 if (nodeoffset < 0) { 334 /* 335 * Not found or something else bad happened. 336 */ 337 printf("libfdt fdt_path_offset() returned %s\n", 338 fdt_strerror(nodeoffset)); 339 return 1; 340 } 341 342 if (subcmd[0] == 'n' || (subcmd[0] == 's' && argc == 5)) { 343 int reqIndex = -1; 344 int startDepth = fdt_node_depth( 345 working_fdt, nodeoffset); 346 int curDepth = startDepth; 347 int curIndex = -1; 348 int nextNodeOffset = fdt_next_node( 349 working_fdt, nodeoffset, &curDepth); 350 351 if (subcmd[0] == 'n') 352 reqIndex = simple_strtoul(argv[5], NULL, 16); 353 354 while (curDepth > startDepth) { 355 if (curDepth == startDepth + 1) 356 curIndex++; 357 if (subcmd[0] == 'n' && curIndex == reqIndex) { 358 const char *node_name; 359 360 node_name = fdt_get_name(working_fdt, 361 nextNodeOffset, 362 NULL); 363 env_set(var, node_name); 364 return 0; 365 } 366 nextNodeOffset = fdt_next_node( 367 working_fdt, nextNodeOffset, &curDepth); 368 if (nextNodeOffset < 0) 369 break; 370 } 371 if (subcmd[0] == 's') { 372 /* get the num nodes at this level */ 373 env_set_ulong(var, curIndex + 1); 374 } else { 375 /* node index not found */ 376 printf("libfdt node not found\n"); 377 return 1; 378 } 379 } else { 380 nodep = fdt_getprop( 381 working_fdt, nodeoffset, prop, &len); 382 if (len == 0) { 383 /* no property value */ 384 env_set(var, ""); 385 return 0; 386 } else if (nodep && len > 0) { 387 if (subcmd[0] == 'v') { 388 int ret; 389 390 ret = fdt_value_env_set(nodep, len, 391 var); 392 if (ret != 0) 393 return ret; 394 } else if (subcmd[0] == 'a') { 395 /* Get address */ 396 char buf[11]; 397 398 sprintf(buf, "0x%p", nodep); 399 env_set(var, buf); 400 } else if (subcmd[0] == 's') { 401 /* Get size */ 402 char buf[11]; 403 404 sprintf(buf, "0x%08X", len); 405 env_set(var, buf); 406 } else 407 return CMD_RET_USAGE; 408 return 0; 409 } else { 410 printf("libfdt fdt_getprop(): %s\n", 411 fdt_strerror(len)); 412 return 1; 413 } 414 } 415 416 /* 417 * Print (recursive) / List (single level) 418 */ 419 } else if ((argv[1][0] == 'p') || (argv[1][0] == 'l')) { 420 int depth = MAX_LEVEL; /* how deep to print */ 421 char *pathp; /* path */ 422 char *prop; /* property */ 423 int ret; /* return value */ 424 static char root[2] = "/"; 425 426 /* 427 * list is an alias for print, but limited to 1 level 428 */ 429 if (argv[1][0] == 'l') { 430 depth = 1; 431 } 432 433 /* 434 * Get the starting path. The root node is an oddball, 435 * the offset is zero and has no name. 436 */ 437 if (argc == 2) 438 pathp = root; 439 else 440 pathp = argv[2]; 441 if (argc > 3) 442 prop = argv[3]; 443 else 444 prop = NULL; 445 446 ret = fdt_print(pathp, prop, depth); 447 if (ret != 0) 448 return ret; 449 450 /* 451 * Remove a property/node 452 */ 453 } else if (strncmp(argv[1], "rm", 2) == 0) { 454 int nodeoffset; /* node offset from libfdt */ 455 int err; 456 457 /* 458 * Get the path. The root node is an oddball, the offset 459 * is zero and has no name. 460 */ 461 nodeoffset = fdt_path_offset (working_fdt, argv[2]); 462 if (nodeoffset < 0) { 463 /* 464 * Not found or something else bad happened. 465 */ 466 printf ("libfdt fdt_path_offset() returned %s\n", 467 fdt_strerror(nodeoffset)); 468 return 1; 469 } 470 /* 471 * Do the delete. A fourth parameter means delete a property, 472 * otherwise delete the node. 473 */ 474 if (argc > 3) { 475 err = fdt_delprop(working_fdt, nodeoffset, argv[3]); 476 if (err < 0) { 477 printf("libfdt fdt_delprop(): %s\n", 478 fdt_strerror(err)); 479 return err; 480 } 481 } else { 482 err = fdt_del_node(working_fdt, nodeoffset); 483 if (err < 0) { 484 printf("libfdt fdt_del_node(): %s\n", 485 fdt_strerror(err)); 486 return err; 487 } 488 } 489 490 /* 491 * Display header info 492 */ 493 } else if (argv[1][0] == 'h') { 494 u32 version = fdt_version(working_fdt); 495 printf("magic:\t\t\t0x%x\n", fdt_magic(working_fdt)); 496 printf("totalsize:\t\t0x%x (%d)\n", fdt_totalsize(working_fdt), 497 fdt_totalsize(working_fdt)); 498 printf("off_dt_struct:\t\t0x%x\n", 499 fdt_off_dt_struct(working_fdt)); 500 printf("off_dt_strings:\t\t0x%x\n", 501 fdt_off_dt_strings(working_fdt)); 502 printf("off_mem_rsvmap:\t\t0x%x\n", 503 fdt_off_mem_rsvmap(working_fdt)); 504 printf("version:\t\t%d\n", version); 505 printf("last_comp_version:\t%d\n", 506 fdt_last_comp_version(working_fdt)); 507 if (version >= 2) 508 printf("boot_cpuid_phys:\t0x%x\n", 509 fdt_boot_cpuid_phys(working_fdt)); 510 if (version >= 3) 511 printf("size_dt_strings:\t0x%x\n", 512 fdt_size_dt_strings(working_fdt)); 513 if (version >= 17) 514 printf("size_dt_struct:\t\t0x%x\n", 515 fdt_size_dt_struct(working_fdt)); 516 printf("number mem_rsv:\t\t0x%x\n", 517 fdt_num_mem_rsv(working_fdt)); 518 printf("\n"); 519 520 /* 521 * Set boot cpu id 522 */ 523 } else if (strncmp(argv[1], "boo", 3) == 0) { 524 unsigned long tmp = simple_strtoul(argv[2], NULL, 16); 525 fdt_set_boot_cpuid_phys(working_fdt, tmp); 526 527 /* 528 * memory command 529 */ 530 } else if (strncmp(argv[1], "me", 2) == 0) { 531 uint64_t addr, size; 532 int err; 533 addr = simple_strtoull(argv[2], NULL, 16); 534 size = simple_strtoull(argv[3], NULL, 16); 535 err = fdt_fixup_memory(working_fdt, addr, size); 536 if (err < 0) 537 return err; 538 539 /* 540 * mem reserve commands 541 */ 542 } else if (strncmp(argv[1], "rs", 2) == 0) { 543 if (argv[2][0] == 'p') { 544 uint64_t addr, size; 545 int total = fdt_num_mem_rsv(working_fdt); 546 int j, err; 547 printf("index\t\t start\t\t size\n"); 548 printf("-------------------------------" 549 "-----------------\n"); 550 for (j = 0; j < total; j++) { 551 err = fdt_get_mem_rsv(working_fdt, j, &addr, &size); 552 if (err < 0) { 553 printf("libfdt fdt_get_mem_rsv(): %s\n", 554 fdt_strerror(err)); 555 return err; 556 } 557 printf(" %x\t%08x%08x\t%08x%08x\n", j, 558 (u32)(addr >> 32), 559 (u32)(addr & 0xffffffff), 560 (u32)(size >> 32), 561 (u32)(size & 0xffffffff)); 562 } 563 } else if (argv[2][0] == 'a') { 564 uint64_t addr, size; 565 int err; 566 addr = simple_strtoull(argv[3], NULL, 16); 567 size = simple_strtoull(argv[4], NULL, 16); 568 err = fdt_add_mem_rsv(working_fdt, addr, size); 569 570 if (err < 0) { 571 printf("libfdt fdt_add_mem_rsv(): %s\n", 572 fdt_strerror(err)); 573 return err; 574 } 575 } else if (argv[2][0] == 'd') { 576 unsigned long idx = simple_strtoul(argv[3], NULL, 16); 577 int err = fdt_del_mem_rsv(working_fdt, idx); 578 579 if (err < 0) { 580 printf("libfdt fdt_del_mem_rsv(): %s\n", 581 fdt_strerror(err)); 582 return err; 583 } 584 } else { 585 /* Unrecognized command */ 586 return CMD_RET_USAGE; 587 } 588 } 589 #ifdef CONFIG_OF_BOARD_SETUP 590 /* Call the board-specific fixup routine */ 591 else if (strncmp(argv[1], "boa", 3) == 0) { 592 int err = ft_board_setup(working_fdt, gd->bd); 593 594 if (err) { 595 printf("Failed to update board information in FDT: %s\n", 596 fdt_strerror(err)); 597 return CMD_RET_FAILURE; 598 } 599 } 600 #endif 601 /* Create a chosen node */ 602 else if (strncmp(argv[1], "cho", 3) == 0) { 603 unsigned long initrd_start = 0, initrd_end = 0; 604 605 if ((argc != 2) && (argc != 4)) 606 return CMD_RET_USAGE; 607 608 if (argc == 4) { 609 initrd_start = simple_strtoul(argv[2], NULL, 16); 610 initrd_end = simple_strtoul(argv[3], NULL, 16); 611 } 612 613 fdt_chosen(working_fdt); 614 fdt_initrd(working_fdt, initrd_start, initrd_end); 615 616 #if defined(CONFIG_FIT_SIGNATURE) 617 } else if (strncmp(argv[1], "che", 3) == 0) { 618 int cfg_noffset; 619 int ret; 620 unsigned long addr; 621 struct fdt_header *blob; 622 623 if (!working_fdt) 624 return CMD_RET_FAILURE; 625 626 if (argc > 2) { 627 addr = simple_strtoul(argv[2], NULL, 16); 628 blob = map_sysmem(addr, 0); 629 } else { 630 blob = (struct fdt_header *)gd->fdt_blob; 631 } 632 if (!fdt_valid(&blob)) 633 return 1; 634 635 gd->fdt_blob = blob; 636 cfg_noffset = fit_conf_get_node(working_fdt, NULL); 637 if (!cfg_noffset) { 638 printf("Could not find configuration node: %s\n", 639 fdt_strerror(cfg_noffset)); 640 return CMD_RET_FAILURE; 641 } 642 643 ret = fit_config_verify(working_fdt, cfg_noffset); 644 if (ret == 0) 645 return CMD_RET_SUCCESS; 646 else 647 return CMD_RET_FAILURE; 648 #endif 649 650 } 651 #ifdef CONFIG_OF_LIBFDT_OVERLAY 652 /* apply an overlay */ 653 else if (strncmp(argv[1], "ap", 2) == 0) { 654 unsigned long addr; 655 struct fdt_header *blob; 656 int ret; 657 658 if (argc != 3) 659 return CMD_RET_USAGE; 660 661 if (!working_fdt) 662 return CMD_RET_FAILURE; 663 664 addr = simple_strtoul(argv[2], NULL, 16); 665 blob = map_sysmem(addr, 0); 666 if (!fdt_valid(&blob)) 667 return CMD_RET_FAILURE; 668 669 /* apply method prints messages on error */ 670 ret = fdt_overlay_apply_verbose(working_fdt, blob); 671 if (ret) 672 return CMD_RET_FAILURE; 673 } 674 #endif 675 /* resize the fdt */ 676 else if (strncmp(argv[1], "re", 2) == 0) { 677 uint extrasize; 678 if (argc > 2) 679 extrasize = simple_strtoul(argv[2], NULL, 16); 680 else 681 extrasize = 0; 682 fdt_shrink_to_minimum(working_fdt, extrasize); 683 } 684 else { 685 /* Unrecognized command */ 686 return CMD_RET_USAGE; 687 } 688 689 return 0; 690 } 691 692 /****************************************************************************/ 693 694 /** 695 * fdt_valid() - Check if an FDT is valid. If not, change it to NULL 696 * 697 * @blobp: Pointer to FDT pointer 698 * @return 1 if OK, 0 if bad (in which case *blobp is set to NULL) 699 */ 700 static int fdt_valid(struct fdt_header **blobp) 701 { 702 const void *blob = *blobp; 703 int err; 704 705 if (blob == NULL) { 706 printf ("The address of the fdt is invalid (NULL).\n"); 707 return 0; 708 } 709 710 err = fdt_check_header(blob); 711 if (err == 0) 712 return 1; /* valid */ 713 714 if (err < 0) { 715 printf("libfdt fdt_check_header(): %s", fdt_strerror(err)); 716 /* 717 * Be more informative on bad version. 718 */ 719 if (err == -FDT_ERR_BADVERSION) { 720 if (fdt_version(blob) < 721 FDT_FIRST_SUPPORTED_VERSION) { 722 printf (" - too old, fdt %d < %d", 723 fdt_version(blob), 724 FDT_FIRST_SUPPORTED_VERSION); 725 } 726 if (fdt_last_comp_version(blob) > 727 FDT_LAST_SUPPORTED_VERSION) { 728 printf (" - too new, fdt %d > %d", 729 fdt_version(blob), 730 FDT_LAST_SUPPORTED_VERSION); 731 } 732 } 733 printf("\n"); 734 *blobp = NULL; 735 return 0; 736 } 737 return 1; 738 } 739 740 /****************************************************************************/ 741 742 /* 743 * Parse the user's input, partially heuristic. Valid formats: 744 * <0x00112233 4 05> - an array of cells. Numbers follow standard 745 * C conventions. 746 * [00 11 22 .. nn] - byte stream 747 * "string" - If the the value doesn't start with "<" or "[", it is 748 * treated as a string. Note that the quotes are 749 * stripped by the parser before we get the string. 750 * newval: An array of strings containing the new property as specified 751 * on the command line 752 * count: The number of strings in the array 753 * data: A bytestream to be placed in the property 754 * len: The length of the resulting bytestream 755 */ 756 static int fdt_parse_prop(char * const *newval, int count, char *data, int *len) 757 { 758 char *cp; /* temporary char pointer */ 759 char *newp; /* temporary newval char pointer */ 760 unsigned long tmp; /* holds converted values */ 761 int stridx = 0; 762 763 *len = 0; 764 newp = newval[0]; 765 766 /* An array of cells */ 767 if (*newp == '<') { 768 newp++; 769 while ((*newp != '>') && (stridx < count)) { 770 /* 771 * Keep searching until we find that last ">" 772 * That way users don't have to escape the spaces 773 */ 774 if (*newp == '\0') { 775 newp = newval[++stridx]; 776 continue; 777 } 778 779 cp = newp; 780 tmp = simple_strtoul(cp, &newp, 0); 781 if (*cp != '?') 782 *(fdt32_t *)data = cpu_to_fdt32(tmp); 783 else 784 newp++; 785 786 data += 4; 787 *len += 4; 788 789 /* If the ptr didn't advance, something went wrong */ 790 if ((newp - cp) <= 0) { 791 printf("Sorry, I could not convert \"%s\"\n", 792 cp); 793 return 1; 794 } 795 796 while (*newp == ' ') 797 newp++; 798 } 799 800 if (*newp != '>') { 801 printf("Unexpected character '%c'\n", *newp); 802 return 1; 803 } 804 } else if (*newp == '[') { 805 /* 806 * Byte stream. Convert the values. 807 */ 808 newp++; 809 while ((stridx < count) && (*newp != ']')) { 810 while (*newp == ' ') 811 newp++; 812 if (*newp == '\0') { 813 newp = newval[++stridx]; 814 continue; 815 } 816 if (!isxdigit(*newp)) 817 break; 818 tmp = simple_strtoul(newp, &newp, 16); 819 *data++ = tmp & 0xFF; 820 *len = *len + 1; 821 } 822 if (*newp != ']') { 823 printf("Unexpected character '%c'\n", *newp); 824 return 1; 825 } 826 } else { 827 /* 828 * Assume it is one or more strings. Copy it into our 829 * data area for convenience (including the 830 * terminating '\0's). 831 */ 832 while (stridx < count) { 833 size_t length = strlen(newp) + 1; 834 strcpy(data, newp); 835 data += length; 836 *len += length; 837 newp = newval[++stridx]; 838 } 839 } 840 return 0; 841 } 842 843 /****************************************************************************/ 844 845 /* 846 * Heuristic to guess if this is a string or concatenated strings. 847 */ 848 849 static int is_printable_string(const void *data, int len) 850 { 851 const char *s = data; 852 853 /* zero length is not */ 854 if (len == 0) 855 return 0; 856 857 /* must terminate with zero or '\n' */ 858 if (s[len - 1] != '\0' && s[len - 1] != '\n') 859 return 0; 860 861 /* printable or a null byte (concatenated strings) */ 862 while (((*s == '\0') || isprint(*s) || isspace(*s)) && (len > 0)) { 863 /* 864 * If we see a null, there are three possibilities: 865 * 1) If len == 1, it is the end of the string, printable 866 * 2) Next character also a null, not printable. 867 * 3) Next character not a null, continue to check. 868 */ 869 if (s[0] == '\0') { 870 if (len == 1) 871 return 1; 872 if (s[1] == '\0') 873 return 0; 874 } 875 s++; 876 len--; 877 } 878 879 /* Not the null termination, or not done yet: not printable */ 880 if (*s != '\0' || (len != 0)) 881 return 0; 882 883 return 1; 884 } 885 886 887 /* 888 * Print the property in the best format, a heuristic guess. Print as 889 * a string, concatenated strings, a byte, word, double word, or (if all 890 * else fails) it is printed as a stream of bytes. 891 */ 892 static void print_data(const void *data, int len) 893 { 894 int j; 895 896 /* no data, don't print */ 897 if (len == 0) 898 return; 899 900 /* 901 * It is a string, but it may have multiple strings (embedded '\0's). 902 */ 903 if (is_printable_string(data, len)) { 904 puts("\""); 905 j = 0; 906 while (j < len) { 907 if (j > 0) 908 puts("\", \""); 909 puts(data); 910 j += strlen(data) + 1; 911 data += strlen(data) + 1; 912 } 913 puts("\""); 914 return; 915 } 916 917 if ((len %4) == 0) { 918 if (len > CMD_FDT_MAX_DUMP) 919 printf("* 0x%p [0x%08x]", data, len); 920 else { 921 const __be32 *p; 922 923 printf("<"); 924 for (j = 0, p = data; j < len/4; j++) 925 printf("0x%08x%s", fdt32_to_cpu(p[j]), 926 j < (len/4 - 1) ? " " : ""); 927 printf(">"); 928 } 929 } else { /* anything else... hexdump */ 930 if (len > CMD_FDT_MAX_DUMP) 931 printf("* 0x%p [0x%08x]", data, len); 932 else { 933 const u8 *s; 934 935 printf("["); 936 for (j = 0, s = data; j < len; j++) 937 printf("%02x%s", s[j], j < len - 1 ? " " : ""); 938 printf("]"); 939 } 940 } 941 } 942 943 /****************************************************************************/ 944 945 /* 946 * Recursively print (a portion of) the working_fdt. The depth parameter 947 * determines how deeply nested the fdt is printed. 948 */ 949 static int fdt_print(const char *pathp, char *prop, int depth) 950 { 951 static char tabs[MAX_LEVEL+1] = 952 "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t" 953 "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"; 954 const void *nodep; /* property node pointer */ 955 int nodeoffset; /* node offset from libfdt */ 956 int nextoffset; /* next node offset from libfdt */ 957 uint32_t tag; /* tag */ 958 int len; /* length of the property */ 959 int level = 0; /* keep track of nesting level */ 960 const struct fdt_property *fdt_prop; 961 962 nodeoffset = fdt_path_offset (working_fdt, pathp); 963 if (nodeoffset < 0) { 964 /* 965 * Not found or something else bad happened. 966 */ 967 printf ("libfdt fdt_path_offset() returned %s\n", 968 fdt_strerror(nodeoffset)); 969 return 1; 970 } 971 /* 972 * The user passed in a property as well as node path. 973 * Print only the given property and then return. 974 */ 975 if (prop) { 976 nodep = fdt_getprop (working_fdt, nodeoffset, prop, &len); 977 if (len == 0) { 978 /* no property value */ 979 printf("%s %s\n", pathp, prop); 980 return 0; 981 } else if (nodep && len > 0) { 982 printf("%s = ", prop); 983 print_data (nodep, len); 984 printf("\n"); 985 return 0; 986 } else { 987 printf ("libfdt fdt_getprop(): %s\n", 988 fdt_strerror(len)); 989 return 1; 990 } 991 } 992 993 /* 994 * The user passed in a node path and no property, 995 * print the node and all subnodes. 996 */ 997 while(level >= 0) { 998 tag = fdt_next_tag(working_fdt, nodeoffset, &nextoffset); 999 switch(tag) { 1000 case FDT_BEGIN_NODE: 1001 pathp = fdt_get_name(working_fdt, nodeoffset, NULL); 1002 if (level <= depth) { 1003 if (pathp == NULL) 1004 pathp = "/* NULL pointer error */"; 1005 if (*pathp == '\0') 1006 pathp = "/"; /* root is nameless */ 1007 printf("%s%s {\n", 1008 &tabs[MAX_LEVEL - level], pathp); 1009 } 1010 level++; 1011 if (level >= MAX_LEVEL) { 1012 printf("Nested too deep, aborting.\n"); 1013 return 1; 1014 } 1015 break; 1016 case FDT_END_NODE: 1017 level--; 1018 if (level <= depth) 1019 printf("%s};\n", &tabs[MAX_LEVEL - level]); 1020 if (level == 0) { 1021 level = -1; /* exit the loop */ 1022 } 1023 break; 1024 case FDT_PROP: 1025 fdt_prop = fdt_offset_ptr(working_fdt, nodeoffset, 1026 sizeof(*fdt_prop)); 1027 pathp = fdt_string(working_fdt, 1028 fdt32_to_cpu(fdt_prop->nameoff)); 1029 len = fdt32_to_cpu(fdt_prop->len); 1030 nodep = fdt_prop->data; 1031 if (len < 0) { 1032 printf ("libfdt fdt_getprop(): %s\n", 1033 fdt_strerror(len)); 1034 return 1; 1035 } else if (len == 0) { 1036 /* the property has no value */ 1037 if (level <= depth) 1038 printf("%s%s;\n", 1039 &tabs[MAX_LEVEL - level], 1040 pathp); 1041 } else { 1042 if (level <= depth) { 1043 printf("%s%s = ", 1044 &tabs[MAX_LEVEL - level], 1045 pathp); 1046 print_data (nodep, len); 1047 printf(";\n"); 1048 } 1049 } 1050 break; 1051 case FDT_NOP: 1052 printf("%s/* NOP */\n", &tabs[MAX_LEVEL - level]); 1053 break; 1054 case FDT_END: 1055 return 1; 1056 default: 1057 if (level <= depth) 1058 printf("Unknown tag 0x%08X\n", tag); 1059 return 1; 1060 } 1061 nodeoffset = nextoffset; 1062 } 1063 return 0; 1064 } 1065 1066 /********************************************************************/ 1067 #ifdef CONFIG_SYS_LONGHELP 1068 static char fdt_help_text[] = 1069 "addr [-c] <addr> [<length>] - Set the [control] fdt location to <addr>\n" 1070 #ifdef CONFIG_OF_LIBFDT_OVERLAY 1071 "fdt apply <addr> - Apply overlay to the DT\n" 1072 #endif 1073 #ifdef CONFIG_OF_BOARD_SETUP 1074 "fdt boardsetup - Do board-specific set up\n" 1075 #endif 1076 #ifdef CONFIG_OF_SYSTEM_SETUP 1077 "fdt systemsetup - Do system-specific set up\n" 1078 #endif 1079 "fdt move <fdt> <newaddr> <length> - Copy the fdt to <addr> and make it active\n" 1080 "fdt resize [<extrasize>] - Resize fdt to size + padding to 4k addr + some optional <extrasize> if needed\n" 1081 "fdt print <path> [<prop>] - Recursive print starting at <path>\n" 1082 "fdt list <path> [<prop>] - Print one level starting at <path>\n" 1083 "fdt get value <var> <path> <prop> - Get <property> and store in <var>\n" 1084 "fdt get name <var> <path> <index> - Get name of node <index> and store in <var>\n" 1085 "fdt get addr <var> <path> <prop> - Get start address of <property> and store in <var>\n" 1086 "fdt get size <var> <path> [<prop>] - Get size of [<property>] or num nodes and store in <var>\n" 1087 "fdt set <path> <prop> [<val>] - Set <property> [to <val>]\n" 1088 "fdt mknode <path> <node> - Create a new node after <path>\n" 1089 "fdt rm <path> [<prop>] - Delete the node or <property>\n" 1090 "fdt header - Display header info\n" 1091 "fdt bootcpu <id> - Set boot cpuid\n" 1092 "fdt memory <addr> <size> - Add/Update memory node\n" 1093 "fdt rsvmem print - Show current mem reserves\n" 1094 "fdt rsvmem add <addr> <size> - Add a mem reserve\n" 1095 "fdt rsvmem delete <index> - Delete a mem reserves\n" 1096 "fdt chosen [<start> <end>] - Add/update the /chosen branch in the tree\n" 1097 " <start>/<end> - initrd start/end addr\n" 1098 #if defined(CONFIG_FIT_SIGNATURE) 1099 "fdt checksign [<addr>] - check FIT signature\n" 1100 " <start> - addr of key blob\n" 1101 " default gd->fdt_blob\n" 1102 #endif 1103 "NOTE: Dereference aliases by omitting the leading '/', " 1104 "e.g. fdt print ethernet0."; 1105 #endif 1106 1107 U_BOOT_CMD( 1108 fdt, 255, 0, do_fdt, 1109 "flattened device tree utility commands", fdt_help_text 1110 ); 1111