cmd_fdt.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841
  1. /*
  2. * (C) Copyright 2007
  3. * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com
  4. * Based on code written by:
  5. * Pantelis Antoniou <pantelis.antoniou@gmail.com> and
  6. * Matthew McClintock <msm@freescale.com>
  7. *
  8. * See file CREDITS for list of people who contributed to this
  9. * project.
  10. *
  11. * This program is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU General Public License as
  13. * published by the Free Software Foundation; either version 2 of
  14. * the License, or (at your option) any later version.
  15. *
  16. * This program is distributed in the hope that it will be useful,
  17. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19. * GNU General Public License for more details.
  20. *
  21. * You should have received a copy of the GNU General Public License
  22. * along with this program; if not, write to the Free Software
  23. * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  24. * MA 02111-1307 USA
  25. */
  26. #include <common.h>
  27. #include <command.h>
  28. #include <linux/ctype.h>
  29. #include <linux/types.h>
  30. #include <asm/global_data.h>
  31. #include <fdt.h>
  32. #include <libfdt.h>
  33. #include <fdt_support.h>
  34. #define MAX_LEVEL 32 /* how deeply nested we will go */
  35. #define SCRATCHPAD 1024 /* bytes of scratchpad memory */
  36. /*
  37. * Global data (for the gd->bd)
  38. */
  39. DECLARE_GLOBAL_DATA_PTR;
  40. static int fdt_valid(void);
  41. static int fdt_parse_prop(char **newval, int count, char *data, int *len);
  42. static int fdt_print(const char *pathp, char *prop, int depth);
  43. /*
  44. * The working_fdt points to our working flattened device tree.
  45. */
  46. struct fdt_header *working_fdt;
  47. void set_working_fdt_addr(void *addr)
  48. {
  49. char buf[17];
  50. working_fdt = addr;
  51. sprintf(buf, "%lx", (unsigned long)addr);
  52. setenv("fdtaddr", buf);
  53. }
  54. /*
  55. * Flattened Device Tree command, see the help for parameter definitions.
  56. */
  57. int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
  58. {
  59. if (argc < 2) {
  60. cmd_usage(cmdtp);
  61. return 1;
  62. }
  63. /********************************************************************
  64. * Set the address of the fdt
  65. ********************************************************************/
  66. if (argv[1][0] == 'a') {
  67. unsigned long addr;
  68. /*
  69. * Set the address [and length] of the fdt.
  70. */
  71. if (argc == 2) {
  72. if (!fdt_valid()) {
  73. return 1;
  74. }
  75. printf("The address of the fdt is %p\n", working_fdt);
  76. return 0;
  77. }
  78. addr = simple_strtoul(argv[2], NULL, 16);
  79. set_working_fdt_addr((void *)addr);
  80. if (!fdt_valid()) {
  81. return 1;
  82. }
  83. if (argc >= 4) {
  84. int len;
  85. int err;
  86. /*
  87. * Optional new length
  88. */
  89. len = simple_strtoul(argv[3], NULL, 16);
  90. if (len < fdt_totalsize(working_fdt)) {
  91. printf ("New length %d < existing length %d, "
  92. "ignoring.\n",
  93. len, fdt_totalsize(working_fdt));
  94. } else {
  95. /*
  96. * Open in place with a new length.
  97. */
  98. err = fdt_open_into(working_fdt, working_fdt, len);
  99. if (err != 0) {
  100. printf ("libfdt fdt_open_into(): %s\n",
  101. fdt_strerror(err));
  102. }
  103. }
  104. }
  105. /********************************************************************
  106. * Move the working_fdt
  107. ********************************************************************/
  108. } else if (strncmp(argv[1], "mo", 2) == 0) {
  109. struct fdt_header *newaddr;
  110. int len;
  111. int err;
  112. if (argc < 4) {
  113. cmd_usage(cmdtp);
  114. return 1;
  115. }
  116. /*
  117. * Set the address and length of the fdt.
  118. */
  119. working_fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16);
  120. if (!fdt_valid()) {
  121. return 1;
  122. }
  123. newaddr = (struct fdt_header *)simple_strtoul(argv[3],NULL,16);
  124. /*
  125. * If the user specifies a length, use that. Otherwise use the
  126. * current length.
  127. */
  128. if (argc <= 4) {
  129. len = fdt_totalsize(working_fdt);
  130. } else {
  131. len = simple_strtoul(argv[4], NULL, 16);
  132. if (len < fdt_totalsize(working_fdt)) {
  133. printf ("New length 0x%X < existing length "
  134. "0x%X, aborting.\n",
  135. len, fdt_totalsize(working_fdt));
  136. return 1;
  137. }
  138. }
  139. /*
  140. * Copy to the new location.
  141. */
  142. err = fdt_open_into(working_fdt, newaddr, len);
  143. if (err != 0) {
  144. printf ("libfdt fdt_open_into(): %s\n",
  145. fdt_strerror(err));
  146. return 1;
  147. }
  148. working_fdt = newaddr;
  149. /********************************************************************
  150. * Make a new node
  151. ********************************************************************/
  152. } else if (strncmp(argv[1], "mk", 2) == 0) {
  153. char *pathp; /* path */
  154. char *nodep; /* new node to add */
  155. int nodeoffset; /* node offset from libfdt */
  156. int err;
  157. /*
  158. * Parameters: Node path, new node to be appended to the path.
  159. */
  160. if (argc < 4) {
  161. cmd_usage(cmdtp);
  162. return 1;
  163. }
  164. pathp = argv[2];
  165. nodep = argv[3];
  166. nodeoffset = fdt_path_offset (working_fdt, pathp);
  167. if (nodeoffset < 0) {
  168. /*
  169. * Not found or something else bad happened.
  170. */
  171. printf ("libfdt fdt_path_offset() returned %s\n",
  172. fdt_strerror(nodeoffset));
  173. return 1;
  174. }
  175. err = fdt_add_subnode(working_fdt, nodeoffset, nodep);
  176. if (err < 0) {
  177. printf ("libfdt fdt_add_subnode(): %s\n",
  178. fdt_strerror(err));
  179. return 1;
  180. }
  181. /********************************************************************
  182. * Set the value of a property in the working_fdt.
  183. ********************************************************************/
  184. } else if (argv[1][0] == 's') {
  185. char *pathp; /* path */
  186. char *prop; /* property */
  187. int nodeoffset; /* node offset from libfdt */
  188. static char data[SCRATCHPAD]; /* storage for the property */
  189. int len; /* new length of the property */
  190. int ret; /* return value */
  191. /*
  192. * Parameters: Node path, property, optional value.
  193. */
  194. if (argc < 4) {
  195. cmd_usage(cmdtp);
  196. return 1;
  197. }
  198. pathp = argv[2];
  199. prop = argv[3];
  200. if (argc == 4) {
  201. len = 0;
  202. } else {
  203. ret = fdt_parse_prop(&argv[4], argc - 4, data, &len);
  204. if (ret != 0)
  205. return ret;
  206. }
  207. nodeoffset = fdt_path_offset (working_fdt, pathp);
  208. if (nodeoffset < 0) {
  209. /*
  210. * Not found or something else bad happened.
  211. */
  212. printf ("libfdt fdt_path_offset() returned %s\n",
  213. fdt_strerror(nodeoffset));
  214. return 1;
  215. }
  216. ret = fdt_setprop(working_fdt, nodeoffset, prop, data, len);
  217. if (ret < 0) {
  218. printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret));
  219. return 1;
  220. }
  221. /********************************************************************
  222. * Print (recursive) / List (single level)
  223. ********************************************************************/
  224. } else if ((argv[1][0] == 'p') || (argv[1][0] == 'l')) {
  225. int depth = MAX_LEVEL; /* how deep to print */
  226. char *pathp; /* path */
  227. char *prop; /* property */
  228. int ret; /* return value */
  229. static char root[2] = "/";
  230. /*
  231. * list is an alias for print, but limited to 1 level
  232. */
  233. if (argv[1][0] == 'l') {
  234. depth = 1;
  235. }
  236. /*
  237. * Get the starting path. The root node is an oddball,
  238. * the offset is zero and has no name.
  239. */
  240. if (argc == 2)
  241. pathp = root;
  242. else
  243. pathp = argv[2];
  244. if (argc > 3)
  245. prop = argv[3];
  246. else
  247. prop = NULL;
  248. ret = fdt_print(pathp, prop, depth);
  249. if (ret != 0)
  250. return ret;
  251. /********************************************************************
  252. * Remove a property/node
  253. ********************************************************************/
  254. } else if (strncmp(argv[1], "rm", 2) == 0) {
  255. int nodeoffset; /* node offset from libfdt */
  256. int err;
  257. /*
  258. * Get the path. The root node is an oddball, the offset
  259. * is zero and has no name.
  260. */
  261. nodeoffset = fdt_path_offset (working_fdt, argv[2]);
  262. if (nodeoffset < 0) {
  263. /*
  264. * Not found or something else bad happened.
  265. */
  266. printf ("libfdt fdt_path_offset() returned %s\n",
  267. fdt_strerror(nodeoffset));
  268. return 1;
  269. }
  270. /*
  271. * Do the delete. A fourth parameter means delete a property,
  272. * otherwise delete the node.
  273. */
  274. if (argc > 3) {
  275. err = fdt_delprop(working_fdt, nodeoffset, argv[3]);
  276. if (err < 0) {
  277. printf("libfdt fdt_delprop(): %s\n",
  278. fdt_strerror(err));
  279. return err;
  280. }
  281. } else {
  282. err = fdt_del_node(working_fdt, nodeoffset);
  283. if (err < 0) {
  284. printf("libfdt fdt_del_node(): %s\n",
  285. fdt_strerror(err));
  286. return err;
  287. }
  288. }
  289. /********************************************************************
  290. * Display header info
  291. ********************************************************************/
  292. } else if (argv[1][0] == 'h') {
  293. u32 version = fdt_version(working_fdt);
  294. printf("magic:\t\t\t0x%x\n", fdt_magic(working_fdt));
  295. printf("totalsize:\t\t0x%x (%d)\n", fdt_totalsize(working_fdt),
  296. fdt_totalsize(working_fdt));
  297. printf("off_dt_struct:\t\t0x%x\n",
  298. fdt_off_dt_struct(working_fdt));
  299. printf("off_dt_strings:\t\t0x%x\n",
  300. fdt_off_dt_strings(working_fdt));
  301. printf("off_mem_rsvmap:\t\t0x%x\n",
  302. fdt_off_mem_rsvmap(working_fdt));
  303. printf("version:\t\t%d\n", version);
  304. printf("last_comp_version:\t%d\n",
  305. fdt_last_comp_version(working_fdt));
  306. if (version >= 2)
  307. printf("boot_cpuid_phys:\t0x%x\n",
  308. fdt_boot_cpuid_phys(working_fdt));
  309. if (version >= 3)
  310. printf("size_dt_strings:\t0x%x\n",
  311. fdt_size_dt_strings(working_fdt));
  312. if (version >= 17)
  313. printf("size_dt_struct:\t\t0x%x\n",
  314. fdt_size_dt_struct(working_fdt));
  315. printf("number mem_rsv:\t\t0x%x\n",
  316. fdt_num_mem_rsv(working_fdt));
  317. printf("\n");
  318. /********************************************************************
  319. * Set boot cpu id
  320. ********************************************************************/
  321. } else if (strncmp(argv[1], "boo", 3) == 0) {
  322. unsigned long tmp = simple_strtoul(argv[2], NULL, 16);
  323. fdt_set_boot_cpuid_phys(working_fdt, tmp);
  324. /********************************************************************
  325. * memory command
  326. ********************************************************************/
  327. } else if (strncmp(argv[1], "me", 2) == 0) {
  328. uint64_t addr, size;
  329. int err;
  330. addr = simple_strtoull(argv[2], NULL, 16);
  331. size = simple_strtoull(argv[3], NULL, 16);
  332. err = fdt_fixup_memory(working_fdt, addr, size);
  333. if (err < 0)
  334. return err;
  335. /********************************************************************
  336. * mem reserve commands
  337. ********************************************************************/
  338. } else if (strncmp(argv[1], "rs", 2) == 0) {
  339. if (argv[2][0] == 'p') {
  340. uint64_t addr, size;
  341. int total = fdt_num_mem_rsv(working_fdt);
  342. int j, err;
  343. printf("index\t\t start\t\t size\n");
  344. printf("-------------------------------"
  345. "-----------------\n");
  346. for (j = 0; j < total; j++) {
  347. err = fdt_get_mem_rsv(working_fdt, j, &addr, &size);
  348. if (err < 0) {
  349. printf("libfdt fdt_get_mem_rsv(): %s\n",
  350. fdt_strerror(err));
  351. return err;
  352. }
  353. printf(" %x\t%08x%08x\t%08x%08x\n", j,
  354. (u32)(addr >> 32),
  355. (u32)(addr & 0xffffffff),
  356. (u32)(size >> 32),
  357. (u32)(size & 0xffffffff));
  358. }
  359. } else if (argv[2][0] == 'a') {
  360. uint64_t addr, size;
  361. int err;
  362. addr = simple_strtoull(argv[3], NULL, 16);
  363. size = simple_strtoull(argv[4], NULL, 16);
  364. err = fdt_add_mem_rsv(working_fdt, addr, size);
  365. if (err < 0) {
  366. printf("libfdt fdt_add_mem_rsv(): %s\n",
  367. fdt_strerror(err));
  368. return err;
  369. }
  370. } else if (argv[2][0] == 'd') {
  371. unsigned long idx = simple_strtoul(argv[3], NULL, 16);
  372. int err = fdt_del_mem_rsv(working_fdt, idx);
  373. if (err < 0) {
  374. printf("libfdt fdt_del_mem_rsv(): %s\n",
  375. fdt_strerror(err));
  376. return err;
  377. }
  378. } else {
  379. /* Unrecognized command */
  380. cmd_usage(cmdtp);
  381. return 1;
  382. }
  383. }
  384. #ifdef CONFIG_OF_BOARD_SETUP
  385. /* Call the board-specific fixup routine */
  386. else if (strncmp(argv[1], "boa", 3) == 0)
  387. ft_board_setup(working_fdt, gd->bd);
  388. #endif
  389. /* Create a chosen node */
  390. else if (argv[1][0] == 'c') {
  391. unsigned long initrd_start = 0, initrd_end = 0;
  392. if ((argc != 2) && (argc != 4)) {
  393. cmd_usage(cmdtp);
  394. return 1;
  395. }
  396. if (argc == 4) {
  397. initrd_start = simple_strtoul(argv[2], NULL, 16);
  398. initrd_end = simple_strtoul(argv[3], NULL, 16);
  399. }
  400. fdt_chosen(working_fdt, 1);
  401. fdt_initrd(working_fdt, initrd_start, initrd_end, 1);
  402. }
  403. /* resize the fdt */
  404. else if (strncmp(argv[1], "re", 2) == 0) {
  405. fdt_resize(working_fdt);
  406. }
  407. else {
  408. /* Unrecognized command */
  409. cmd_usage(cmdtp);
  410. return 1;
  411. }
  412. return 0;
  413. }
  414. /****************************************************************************/
  415. static int fdt_valid(void)
  416. {
  417. int err;
  418. if (working_fdt == NULL) {
  419. printf ("The address of the fdt is invalid (NULL).\n");
  420. return 0;
  421. }
  422. err = fdt_check_header(working_fdt);
  423. if (err == 0)
  424. return 1; /* valid */
  425. if (err < 0) {
  426. printf("libfdt fdt_check_header(): %s", fdt_strerror(err));
  427. /*
  428. * Be more informative on bad version.
  429. */
  430. if (err == -FDT_ERR_BADVERSION) {
  431. if (fdt_version(working_fdt) <
  432. FDT_FIRST_SUPPORTED_VERSION) {
  433. printf (" - too old, fdt %d < %d",
  434. fdt_version(working_fdt),
  435. FDT_FIRST_SUPPORTED_VERSION);
  436. working_fdt = NULL;
  437. }
  438. if (fdt_last_comp_version(working_fdt) >
  439. FDT_LAST_SUPPORTED_VERSION) {
  440. printf (" - too new, fdt %d > %d",
  441. fdt_version(working_fdt),
  442. FDT_LAST_SUPPORTED_VERSION);
  443. working_fdt = NULL;
  444. }
  445. return 0;
  446. }
  447. printf("\n");
  448. return 0;
  449. }
  450. return 1;
  451. }
  452. /****************************************************************************/
  453. /*
  454. * Parse the user's input, partially heuristic. Valid formats:
  455. * <0x00112233 4 05> - an array of cells. Numbers follow standard
  456. * C conventions.
  457. * [00 11 22 .. nn] - byte stream
  458. * "string" - If the the value doesn't start with "<" or "[", it is
  459. * treated as a string. Note that the quotes are
  460. * stripped by the parser before we get the string.
  461. * newval: An array of strings containing the new property as specified
  462. * on the command line
  463. * count: The number of strings in the array
  464. * data: A bytestream to be placed in the property
  465. * len: The length of the resulting bytestream
  466. */
  467. static int fdt_parse_prop(char **newval, int count, char *data, int *len)
  468. {
  469. char *cp; /* temporary char pointer */
  470. char *newp; /* temporary newval char pointer */
  471. unsigned long tmp; /* holds converted values */
  472. int stridx = 0;
  473. *len = 0;
  474. newp = newval[0];
  475. /* An array of cells */
  476. if (*newp == '<') {
  477. newp++;
  478. while ((*newp != '>') && (stridx < count)) {
  479. /*
  480. * Keep searching until we find that last ">"
  481. * That way users don't have to escape the spaces
  482. */
  483. if (*newp == '\0') {
  484. newp = newval[++stridx];
  485. continue;
  486. }
  487. cp = newp;
  488. tmp = simple_strtoul(cp, &newp, 0);
  489. *(uint32_t *)data = __cpu_to_be32(tmp);
  490. data += 4;
  491. *len += 4;
  492. /* If the ptr didn't advance, something went wrong */
  493. if ((newp - cp) <= 0) {
  494. printf("Sorry, I could not convert \"%s\"\n",
  495. cp);
  496. return 1;
  497. }
  498. while (*newp == ' ')
  499. newp++;
  500. }
  501. if (*newp != '>') {
  502. printf("Unexpected character '%c'\n", *newp);
  503. return 1;
  504. }
  505. } else if (*newp == '[') {
  506. /*
  507. * Byte stream. Convert the values.
  508. */
  509. newp++;
  510. while ((stridx < count) && (*newp != ']')) {
  511. while (*newp == ' ')
  512. newp++;
  513. if (*newp == '\0') {
  514. newp = newval[++stridx];
  515. continue;
  516. }
  517. if (!isxdigit(*newp))
  518. break;
  519. tmp = simple_strtoul(newp, &newp, 16);
  520. *data++ = tmp & 0xFF;
  521. *len = *len + 1;
  522. }
  523. if (*newp != ']') {
  524. printf("Unexpected character '%c'\n", *newp);
  525. return 1;
  526. }
  527. } else {
  528. /*
  529. * Assume it is one or more strings. Copy it into our
  530. * data area for convenience (including the
  531. * terminating '\0's).
  532. */
  533. while (stridx < count) {
  534. size_t length = strlen(newp) + 1;
  535. strcpy(data, newp);
  536. data += length;
  537. *len += length;
  538. newp = newval[++stridx];
  539. }
  540. }
  541. return 0;
  542. }
  543. /****************************************************************************/
  544. /*
  545. * Heuristic to guess if this is a string or concatenated strings.
  546. */
  547. static int is_printable_string(const void *data, int len)
  548. {
  549. const char *s = data;
  550. /* zero length is not */
  551. if (len == 0)
  552. return 0;
  553. /* must terminate with zero */
  554. if (s[len - 1] != '\0')
  555. return 0;
  556. /* printable or a null byte (concatenated strings) */
  557. while (((*s == '\0') || isprint(*s)) && (len > 0)) {
  558. /*
  559. * If we see a null, there are three possibilities:
  560. * 1) If len == 1, it is the end of the string, printable
  561. * 2) Next character also a null, not printable.
  562. * 3) Next character not a null, continue to check.
  563. */
  564. if (s[0] == '\0') {
  565. if (len == 1)
  566. return 1;
  567. if (s[1] == '\0')
  568. return 0;
  569. }
  570. s++;
  571. len--;
  572. }
  573. /* Not the null termination, or not done yet: not printable */
  574. if (*s != '\0' || (len != 0))
  575. return 0;
  576. return 1;
  577. }
  578. /*
  579. * Print the property in the best format, a heuristic guess. Print as
  580. * a string, concatenated strings, a byte, word, double word, or (if all
  581. * else fails) it is printed as a stream of bytes.
  582. */
  583. static void print_data(const void *data, int len)
  584. {
  585. int j;
  586. /* no data, don't print */
  587. if (len == 0)
  588. return;
  589. /*
  590. * It is a string, but it may have multiple strings (embedded '\0's).
  591. */
  592. if (is_printable_string(data, len)) {
  593. puts("\"");
  594. j = 0;
  595. while (j < len) {
  596. if (j > 0)
  597. puts("\", \"");
  598. puts(data);
  599. j += strlen(data) + 1;
  600. data += strlen(data) + 1;
  601. }
  602. puts("\"");
  603. return;
  604. }
  605. if ((len %4) == 0) {
  606. const u32 *p;
  607. printf("<");
  608. for (j = 0, p = data; j < len/4; j ++)
  609. printf("0x%x%s", p[j], j < (len/4 - 1) ? " " : "");
  610. printf(">");
  611. } else { /* anything else... hexdump */
  612. const u8 *s;
  613. printf("[");
  614. for (j = 0, s = data; j < len; j++)
  615. printf("%02x%s", s[j], j < len - 1 ? " " : "");
  616. printf("]");
  617. }
  618. }
  619. /****************************************************************************/
  620. /*
  621. * Recursively print (a portion of) the working_fdt. The depth parameter
  622. * determines how deeply nested the fdt is printed.
  623. */
  624. static int fdt_print(const char *pathp, char *prop, int depth)
  625. {
  626. static char tabs[MAX_LEVEL+1] =
  627. "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"
  628. "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
  629. const void *nodep; /* property node pointer */
  630. int nodeoffset; /* node offset from libfdt */
  631. int nextoffset; /* next node offset from libfdt */
  632. uint32_t tag; /* tag */
  633. int len; /* length of the property */
  634. int level = 0; /* keep track of nesting level */
  635. const struct fdt_property *fdt_prop;
  636. nodeoffset = fdt_path_offset (working_fdt, pathp);
  637. if (nodeoffset < 0) {
  638. /*
  639. * Not found or something else bad happened.
  640. */
  641. printf ("libfdt fdt_path_offset() returned %s\n",
  642. fdt_strerror(nodeoffset));
  643. return 1;
  644. }
  645. /*
  646. * The user passed in a property as well as node path.
  647. * Print only the given property and then return.
  648. */
  649. if (prop) {
  650. nodep = fdt_getprop (working_fdt, nodeoffset, prop, &len);
  651. if (len == 0) {
  652. /* no property value */
  653. printf("%s %s\n", pathp, prop);
  654. return 0;
  655. } else if (len > 0) {
  656. printf("%s = ", prop);
  657. print_data (nodep, len);
  658. printf("\n");
  659. return 0;
  660. } else {
  661. printf ("libfdt fdt_getprop(): %s\n",
  662. fdt_strerror(len));
  663. return 1;
  664. }
  665. }
  666. /*
  667. * The user passed in a node path and no property,
  668. * print the node and all subnodes.
  669. */
  670. while(level >= 0) {
  671. tag = fdt_next_tag(working_fdt, nodeoffset, &nextoffset);
  672. switch(tag) {
  673. case FDT_BEGIN_NODE:
  674. pathp = fdt_get_name(working_fdt, nodeoffset, NULL);
  675. if (level <= depth) {
  676. if (pathp == NULL)
  677. pathp = "/* NULL pointer error */";
  678. if (*pathp == '\0')
  679. pathp = "/"; /* root is nameless */
  680. printf("%s%s {\n",
  681. &tabs[MAX_LEVEL - level], pathp);
  682. }
  683. level++;
  684. if (level >= MAX_LEVEL) {
  685. printf("Nested too deep, aborting.\n");
  686. return 1;
  687. }
  688. break;
  689. case FDT_END_NODE:
  690. level--;
  691. if (level <= depth)
  692. printf("%s};\n", &tabs[MAX_LEVEL - level]);
  693. if (level == 0) {
  694. level = -1; /* exit the loop */
  695. }
  696. break;
  697. case FDT_PROP:
  698. fdt_prop = fdt_offset_ptr(working_fdt, nodeoffset,
  699. sizeof(*fdt_prop));
  700. pathp = fdt_string(working_fdt,
  701. fdt32_to_cpu(fdt_prop->nameoff));
  702. len = fdt32_to_cpu(fdt_prop->len);
  703. nodep = fdt_prop->data;
  704. if (len < 0) {
  705. printf ("libfdt fdt_getprop(): %s\n",
  706. fdt_strerror(len));
  707. return 1;
  708. } else if (len == 0) {
  709. /* the property has no value */
  710. if (level <= depth)
  711. printf("%s%s;\n",
  712. &tabs[MAX_LEVEL - level],
  713. pathp);
  714. } else {
  715. if (level <= depth) {
  716. printf("%s%s = ",
  717. &tabs[MAX_LEVEL - level],
  718. pathp);
  719. print_data (nodep, len);
  720. printf(";\n");
  721. }
  722. }
  723. break;
  724. case FDT_NOP:
  725. printf("%s/* NOP */\n", &tabs[MAX_LEVEL - level]);
  726. break;
  727. case FDT_END:
  728. return 1;
  729. default:
  730. if (level <= depth)
  731. printf("Unknown tag 0x%08X\n", tag);
  732. return 1;
  733. }
  734. nodeoffset = nextoffset;
  735. }
  736. return 0;
  737. }
  738. /********************************************************************/
  739. U_BOOT_CMD(
  740. fdt, 255, 0, do_fdt,
  741. "flattened device tree utility commands",
  742. "addr <addr> [<length>] - Set the fdt location to <addr>\n"
  743. #ifdef CONFIG_OF_BOARD_SETUP
  744. "fdt boardsetup - Do board-specific set up\n"
  745. #endif
  746. "fdt move <fdt> <newaddr> <length> - Copy the fdt to <addr> and make it active\n"
  747. "fdt resize - Resize fdt to size + padding to 4k addr\n"
  748. "fdt print <path> [<prop>] - Recursive print starting at <path>\n"
  749. "fdt list <path> [<prop>] - Print one level starting at <path>\n"
  750. "fdt set <path> <prop> [<val>] - Set <property> [to <val>]\n"
  751. "fdt mknode <path> <node> - Create a new node after <path>\n"
  752. "fdt rm <path> [<prop>] - Delete the node or <property>\n"
  753. "fdt header - Display header info\n"
  754. "fdt bootcpu <id> - Set boot cpuid\n"
  755. "fdt memory <addr> <size> - Add/Update memory node\n"
  756. "fdt rsvmem print - Show current mem reserves\n"
  757. "fdt rsvmem add <addr> <size> - Add a mem reserve\n"
  758. "fdt rsvmem delete <index> - Delete a mem reserves\n"
  759. "fdt chosen [<start> <end>] - Add/update the /chosen branch in the tree\n"
  760. " <start>/<end> - initrd start/end addr\n"
  761. "NOTE: Dereference aliases by omiting the leading '/', "
  762. "e.g. fdt print ethernet0."
  763. );