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