1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2007 4 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com 5 * Based on code written by: 6 * Pantelis Antoniou <pantelis.antoniou@gmail.com> and 7 * Matthew McClintock <msm@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 #ifdef CONFIG_SOC_KEYSTONE 600 ft_board_setup_ex(working_fdt, gd->bd); 601 #endif 602 } 603 #endif 604 /* Create a chosen node */ 605 else if (strncmp(argv[1], "cho", 3) == 0) { 606 unsigned long initrd_start = 0, initrd_end = 0; 607 608 if ((argc != 2) && (argc != 4)) 609 return CMD_RET_USAGE; 610 611 if (argc == 4) { 612 initrd_start = simple_strtoul(argv[2], NULL, 16); 613 initrd_end = simple_strtoul(argv[3], NULL, 16); 614 } 615 616 fdt_chosen(working_fdt); 617 fdt_initrd(working_fdt, initrd_start, initrd_end); 618 619 #if defined(CONFIG_FIT_SIGNATURE) 620 } else if (strncmp(argv[1], "che", 3) == 0) { 621 int cfg_noffset; 622 int ret; 623 unsigned long addr; 624 struct fdt_header *blob; 625 626 if (!working_fdt) 627 return CMD_RET_FAILURE; 628 629 if (argc > 2) { 630 addr = simple_strtoul(argv[2], NULL, 16); 631 blob = map_sysmem(addr, 0); 632 } else { 633 blob = (struct fdt_header *)gd->fdt_blob; 634 } 635 if (!fdt_valid(&blob)) 636 return 1; 637 638 gd->fdt_blob = blob; 639 cfg_noffset = fit_conf_get_node(working_fdt, NULL); 640 if (!cfg_noffset) { 641 printf("Could not find configuration node: %s\n", 642 fdt_strerror(cfg_noffset)); 643 return CMD_RET_FAILURE; 644 } 645 646 ret = fit_config_verify(working_fdt, cfg_noffset); 647 if (ret == 0) 648 return CMD_RET_SUCCESS; 649 else 650 return CMD_RET_FAILURE; 651 #endif 652 653 } 654 #ifdef CONFIG_OF_LIBFDT_OVERLAY 655 /* apply an overlay */ 656 else if (strncmp(argv[1], "ap", 2) == 0) { 657 unsigned long addr; 658 struct fdt_header *blob; 659 int ret; 660 661 if (argc != 3) 662 return CMD_RET_USAGE; 663 664 if (!working_fdt) 665 return CMD_RET_FAILURE; 666 667 addr = simple_strtoul(argv[2], NULL, 16); 668 blob = map_sysmem(addr, 0); 669 if (!fdt_valid(&blob)) 670 return CMD_RET_FAILURE; 671 672 /* apply method prints messages on error */ 673 ret = fdt_overlay_apply_verbose(working_fdt, blob); 674 if (ret) 675 return CMD_RET_FAILURE; 676 } 677 #endif 678 /* resize the fdt */ 679 else if (strncmp(argv[1], "re", 2) == 0) { 680 uint extrasize; 681 if (argc > 2) 682 extrasize = simple_strtoul(argv[2], NULL, 16); 683 else 684 extrasize = 0; 685 fdt_shrink_to_minimum(working_fdt, extrasize); 686 } 687 else { 688 /* Unrecognized command */ 689 return CMD_RET_USAGE; 690 } 691 692 return 0; 693 } 694 695 /****************************************************************************/ 696 697 /** 698 * fdt_valid() - Check if an FDT is valid. If not, change it to NULL 699 * 700 * @blobp: Pointer to FDT pointer 701 * @return 1 if OK, 0 if bad (in which case *blobp is set to NULL) 702 */ 703 static int fdt_valid(struct fdt_header **blobp) 704 { 705 const void *blob = *blobp; 706 int err; 707 708 if (blob == NULL) { 709 printf ("The address of the fdt is invalid (NULL).\n"); 710 return 0; 711 } 712 713 err = fdt_check_header(blob); 714 if (err == 0) 715 return 1; /* valid */ 716 717 if (err < 0) { 718 printf("libfdt fdt_check_header(): %s", fdt_strerror(err)); 719 /* 720 * Be more informative on bad version. 721 */ 722 if (err == -FDT_ERR_BADVERSION) { 723 if (fdt_version(blob) < 724 FDT_FIRST_SUPPORTED_VERSION) { 725 printf (" - too old, fdt %d < %d", 726 fdt_version(blob), 727 FDT_FIRST_SUPPORTED_VERSION); 728 } 729 if (fdt_last_comp_version(blob) > 730 FDT_LAST_SUPPORTED_VERSION) { 731 printf (" - too new, fdt %d > %d", 732 fdt_version(blob), 733 FDT_LAST_SUPPORTED_VERSION); 734 } 735 } 736 printf("\n"); 737 *blobp = NULL; 738 return 0; 739 } 740 return 1; 741 } 742 743 /****************************************************************************/ 744 745 /* 746 * Parse the user's input, partially heuristic. Valid formats: 747 * <0x00112233 4 05> - an array of cells. Numbers follow standard 748 * C conventions. 749 * [00 11 22 .. nn] - byte stream 750 * "string" - If the the value doesn't start with "<" or "[", it is 751 * treated as a string. Note that the quotes are 752 * stripped by the parser before we get the string. 753 * newval: An array of strings containing the new property as specified 754 * on the command line 755 * count: The number of strings in the array 756 * data: A bytestream to be placed in the property 757 * len: The length of the resulting bytestream 758 */ 759 static int fdt_parse_prop(char * const *newval, int count, char *data, int *len) 760 { 761 char *cp; /* temporary char pointer */ 762 char *newp; /* temporary newval char pointer */ 763 unsigned long tmp; /* holds converted values */ 764 int stridx = 0; 765 766 *len = 0; 767 newp = newval[0]; 768 769 /* An array of cells */ 770 if (*newp == '<') { 771 newp++; 772 while ((*newp != '>') && (stridx < count)) { 773 /* 774 * Keep searching until we find that last ">" 775 * That way users don't have to escape the spaces 776 */ 777 if (*newp == '\0') { 778 newp = newval[++stridx]; 779 continue; 780 } 781 782 cp = newp; 783 tmp = simple_strtoul(cp, &newp, 0); 784 if (*cp != '?') 785 *(fdt32_t *)data = cpu_to_fdt32(tmp); 786 else 787 newp++; 788 789 data += 4; 790 *len += 4; 791 792 /* If the ptr didn't advance, something went wrong */ 793 if ((newp - cp) <= 0) { 794 printf("Sorry, I could not convert \"%s\"\n", 795 cp); 796 return 1; 797 } 798 799 while (*newp == ' ') 800 newp++; 801 } 802 803 if (*newp != '>') { 804 printf("Unexpected character '%c'\n", *newp); 805 return 1; 806 } 807 } else if (*newp == '[') { 808 /* 809 * Byte stream. Convert the values. 810 */ 811 newp++; 812 while ((stridx < count) && (*newp != ']')) { 813 while (*newp == ' ') 814 newp++; 815 if (*newp == '\0') { 816 newp = newval[++stridx]; 817 continue; 818 } 819 if (!isxdigit(*newp)) 820 break; 821 tmp = simple_strtoul(newp, &newp, 16); 822 *data++ = tmp & 0xFF; 823 *len = *len + 1; 824 } 825 if (*newp != ']') { 826 printf("Unexpected character '%c'\n", *newp); 827 return 1; 828 } 829 } else { 830 /* 831 * Assume it is one or more strings. Copy it into our 832 * data area for convenience (including the 833 * terminating '\0's). 834 */ 835 while (stridx < count) { 836 size_t length = strlen(newp) + 1; 837 strcpy(data, newp); 838 data += length; 839 *len += length; 840 newp = newval[++stridx]; 841 } 842 } 843 return 0; 844 } 845 846 /****************************************************************************/ 847 848 /* 849 * Heuristic to guess if this is a string or concatenated strings. 850 */ 851 852 static int is_printable_string(const void *data, int len) 853 { 854 const char *s = data; 855 856 /* zero length is not */ 857 if (len == 0) 858 return 0; 859 860 /* must terminate with zero or '\n' */ 861 if (s[len - 1] != '\0' && s[len - 1] != '\n') 862 return 0; 863 864 /* printable or a null byte (concatenated strings) */ 865 while (((*s == '\0') || isprint(*s) || isspace(*s)) && (len > 0)) { 866 /* 867 * If we see a null, there are three possibilities: 868 * 1) If len == 1, it is the end of the string, printable 869 * 2) Next character also a null, not printable. 870 * 3) Next character not a null, continue to check. 871 */ 872 if (s[0] == '\0') { 873 if (len == 1) 874 return 1; 875 if (s[1] == '\0') 876 return 0; 877 } 878 s++; 879 len--; 880 } 881 882 /* Not the null termination, or not done yet: not printable */ 883 if (*s != '\0' || (len != 0)) 884 return 0; 885 886 return 1; 887 } 888 889 890 /* 891 * Print the property in the best format, a heuristic guess. Print as 892 * a string, concatenated strings, a byte, word, double word, or (if all 893 * else fails) it is printed as a stream of bytes. 894 */ 895 static void print_data(const void *data, int len) 896 { 897 int j; 898 899 /* no data, don't print */ 900 if (len == 0) 901 return; 902 903 /* 904 * It is a string, but it may have multiple strings (embedded '\0's). 905 */ 906 if (is_printable_string(data, len)) { 907 puts("\""); 908 j = 0; 909 while (j < len) { 910 if (j > 0) 911 puts("\", \""); 912 puts(data); 913 j += strlen(data) + 1; 914 data += strlen(data) + 1; 915 } 916 puts("\""); 917 return; 918 } 919 920 if ((len %4) == 0) { 921 if (len > CMD_FDT_MAX_DUMP) 922 printf("* 0x%p [0x%08x]", data, len); 923 else { 924 const __be32 *p; 925 926 printf("<"); 927 for (j = 0, p = data; j < len/4; j++) 928 printf("0x%08x%s", fdt32_to_cpu(p[j]), 929 j < (len/4 - 1) ? " " : ""); 930 printf(">"); 931 } 932 } else { /* anything else... hexdump */ 933 if (len > CMD_FDT_MAX_DUMP) 934 printf("* 0x%p [0x%08x]", data, len); 935 else { 936 const u8 *s; 937 938 printf("["); 939 for (j = 0, s = data; j < len; j++) 940 printf("%02x%s", s[j], j < len - 1 ? " " : ""); 941 printf("]"); 942 } 943 } 944 } 945 946 /****************************************************************************/ 947 948 /* 949 * Recursively print (a portion of) the working_fdt. The depth parameter 950 * determines how deeply nested the fdt is printed. 951 */ 952 static int fdt_print(const char *pathp, char *prop, int depth) 953 { 954 static char tabs[MAX_LEVEL+1] = 955 "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t" 956 "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"; 957 const void *nodep; /* property node pointer */ 958 int nodeoffset; /* node offset from libfdt */ 959 int nextoffset; /* next node offset from libfdt */ 960 uint32_t tag; /* tag */ 961 int len; /* length of the property */ 962 int level = 0; /* keep track of nesting level */ 963 const struct fdt_property *fdt_prop; 964 965 nodeoffset = fdt_path_offset (working_fdt, pathp); 966 if (nodeoffset < 0) { 967 /* 968 * Not found or something else bad happened. 969 */ 970 printf ("libfdt fdt_path_offset() returned %s\n", 971 fdt_strerror(nodeoffset)); 972 return 1; 973 } 974 /* 975 * The user passed in a property as well as node path. 976 * Print only the given property and then return. 977 */ 978 if (prop) { 979 nodep = fdt_getprop (working_fdt, nodeoffset, prop, &len); 980 if (len == 0) { 981 /* no property value */ 982 printf("%s %s\n", pathp, prop); 983 return 0; 984 } else if (nodep && len > 0) { 985 printf("%s = ", prop); 986 print_data (nodep, len); 987 printf("\n"); 988 return 0; 989 } else { 990 printf ("libfdt fdt_getprop(): %s\n", 991 fdt_strerror(len)); 992 return 1; 993 } 994 } 995 996 /* 997 * The user passed in a node path and no property, 998 * print the node and all subnodes. 999 */ 1000 while(level >= 0) { 1001 tag = fdt_next_tag(working_fdt, nodeoffset, &nextoffset); 1002 switch(tag) { 1003 case FDT_BEGIN_NODE: 1004 pathp = fdt_get_name(working_fdt, nodeoffset, NULL); 1005 if (level <= depth) { 1006 if (pathp == NULL) 1007 pathp = "/* NULL pointer error */"; 1008 if (*pathp == '\0') 1009 pathp = "/"; /* root is nameless */ 1010 printf("%s%s {\n", 1011 &tabs[MAX_LEVEL - level], pathp); 1012 } 1013 level++; 1014 if (level >= MAX_LEVEL) { 1015 printf("Nested too deep, aborting.\n"); 1016 return 1; 1017 } 1018 break; 1019 case FDT_END_NODE: 1020 level--; 1021 if (level <= depth) 1022 printf("%s};\n", &tabs[MAX_LEVEL - level]); 1023 if (level == 0) { 1024 level = -1; /* exit the loop */ 1025 } 1026 break; 1027 case FDT_PROP: 1028 fdt_prop = fdt_offset_ptr(working_fdt, nodeoffset, 1029 sizeof(*fdt_prop)); 1030 pathp = fdt_string(working_fdt, 1031 fdt32_to_cpu(fdt_prop->nameoff)); 1032 len = fdt32_to_cpu(fdt_prop->len); 1033 nodep = fdt_prop->data; 1034 if (len < 0) { 1035 printf ("libfdt fdt_getprop(): %s\n", 1036 fdt_strerror(len)); 1037 return 1; 1038 } else if (len == 0) { 1039 /* the property has no value */ 1040 if (level <= depth) 1041 printf("%s%s;\n", 1042 &tabs[MAX_LEVEL - level], 1043 pathp); 1044 } else { 1045 if (level <= depth) { 1046 printf("%s%s = ", 1047 &tabs[MAX_LEVEL - level], 1048 pathp); 1049 print_data (nodep, len); 1050 printf(";\n"); 1051 } 1052 } 1053 break; 1054 case FDT_NOP: 1055 printf("%s/* NOP */\n", &tabs[MAX_LEVEL - level]); 1056 break; 1057 case FDT_END: 1058 return 1; 1059 default: 1060 if (level <= depth) 1061 printf("Unknown tag 0x%08X\n", tag); 1062 return 1; 1063 } 1064 nodeoffset = nextoffset; 1065 } 1066 return 0; 1067 } 1068 1069 /********************************************************************/ 1070 #ifdef CONFIG_SYS_LONGHELP 1071 static char fdt_help_text[] = 1072 "addr [-c] <addr> [<length>] - Set the [control] fdt location to <addr>\n" 1073 #ifdef CONFIG_OF_LIBFDT_OVERLAY 1074 "fdt apply <addr> - Apply overlay to the DT\n" 1075 #endif 1076 #ifdef CONFIG_OF_BOARD_SETUP 1077 "fdt boardsetup - Do board-specific set up\n" 1078 #endif 1079 #ifdef CONFIG_OF_SYSTEM_SETUP 1080 "fdt systemsetup - Do system-specific set up\n" 1081 #endif 1082 "fdt move <fdt> <newaddr> <length> - Copy the fdt to <addr> and make it active\n" 1083 "fdt resize [<extrasize>] - Resize fdt to size + padding to 4k addr + some optional <extrasize> if needed\n" 1084 "fdt print <path> [<prop>] - Recursive print starting at <path>\n" 1085 "fdt list <path> [<prop>] - Print one level starting at <path>\n" 1086 "fdt get value <var> <path> <prop> - Get <property> and store in <var>\n" 1087 "fdt get name <var> <path> <index> - Get name of node <index> and store in <var>\n" 1088 "fdt get addr <var> <path> <prop> - Get start address of <property> and store in <var>\n" 1089 "fdt get size <var> <path> [<prop>] - Get size of [<property>] or num nodes and store in <var>\n" 1090 "fdt set <path> <prop> [<val>] - Set <property> [to <val>]\n" 1091 "fdt mknode <path> <node> - Create a new node after <path>\n" 1092 "fdt rm <path> [<prop>] - Delete the node or <property>\n" 1093 "fdt header - Display header info\n" 1094 "fdt bootcpu <id> - Set boot cpuid\n" 1095 "fdt memory <addr> <size> - Add/Update memory node\n" 1096 "fdt rsvmem print - Show current mem reserves\n" 1097 "fdt rsvmem add <addr> <size> - Add a mem reserve\n" 1098 "fdt rsvmem delete <index> - Delete a mem reserves\n" 1099 "fdt chosen [<start> <end>] - Add/update the /chosen branch in the tree\n" 1100 " <start>/<end> - initrd start/end addr\n" 1101 #if defined(CONFIG_FIT_SIGNATURE) 1102 "fdt checksign [<addr>] - check FIT signature\n" 1103 " <start> - addr of key blob\n" 1104 " default gd->fdt_blob\n" 1105 #endif 1106 "NOTE: Dereference aliases by omitting the leading '/', " 1107 "e.g. fdt print ethernet0."; 1108 #endif 1109 1110 U_BOOT_CMD( 1111 fdt, 255, 0, do_fdt, 1112 "flattened device tree utility commands", fdt_help_text 1113 ); 1114