blob: 8e51a43126175cfff297dcc4eac07d2c45f5991a [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Gerald Van Barenade8ef42007-03-31 12:22:10 -04002/*
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>
Gerald Van Barenade8ef42007-03-31 12:22:10 -04008 */
9
10#include <common.h>
11#include <command.h>
Simon Glass313112a2019-08-01 09:46:46 -060012#include <env.h>
Simon Glass2dc9c342020-05-10 11:40:01 -060013#include <image.h>
Gerald Van Barenade8ef42007-03-31 12:22:10 -040014#include <linux/ctype.h>
15#include <linux/types.h>
Gerald Van Barenade8ef42007-03-31 12:22:10 -040016#include <asm/global_data.h>
Masahiro Yamada75f82d02018-03-05 01:20:11 +090017#include <linux/libfdt.h>
Gerald Van Barenc4a57ea2007-04-06 14:19:43 -040018#include <fdt_support.h>
Joe Hershberger65b905b2015-03-22 17:08:59 -050019#include <mapmem.h>
Simon Glassb7fc7102013-04-20 08:42:45 +000020#include <asm/io.h>
Gerald Van Barenade8ef42007-03-31 12:22:10 -040021
22#define MAX_LEVEL 32 /* how deeply nested we will go */
Gerald Van Baren5606a362007-06-25 23:25:28 -040023#define SCRATCHPAD 1024 /* bytes of scratchpad memory */
Gerald Van Barenade8ef42007-03-31 12:22:10 -040024
25/*
26 * Global data (for the gd->bd)
27 */
28DECLARE_GLOBAL_DATA_PTR;
29
Wolfgang Denk6262d0212010-06-28 22:00:46 +020030static int fdt_parse_prop(char *const*newval, int count, char *data, int *len);
Kumar Gala1e386af2007-11-21 14:07:46 -060031static int fdt_print(const char *pathp, char *prop, int depth);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +000032static int is_printable_string(const void *data, int len);
Gerald Van Barenade8ef42007-03-31 12:22:10 -040033
Gerald Van Barenade8ef42007-03-31 12:22:10 -040034/*
Gerald Van Barene81ce612008-06-10 22:15:58 -040035 * The working_fdt points to our working flattened device tree.
36 */
37struct fdt_header *working_fdt;
38
Joe Hershberger3d4ea4c2015-02-04 21:56:53 -060039void set_working_fdt_addr(ulong addr)
Kumar Gala9f4e7e42008-08-15 08:24:39 -050040{
Simon Glassb7fc7102013-04-20 08:42:45 +000041 void *buf;
42
Simon Glass84328cf2022-10-11 09:47:12 -060043 printf("Working FDT set to %lx\n", addr);
Joe Hershberger3d4ea4c2015-02-04 21:56:53 -060044 buf = map_sysmem(addr, 0);
Simon Glassb7fc7102013-04-20 08:42:45 +000045 working_fdt = buf;
Simon Glass4d949a22017-08-03 12:22:10 -060046 env_set_hex("fdtaddr", addr);
Kumar Gala9f4e7e42008-08-15 08:24:39 -050047}
48
Gerald Van Barene81ce612008-06-10 22:15:58 -040049/*
Joe Hershbergerfc5abf02012-08-17 10:34:37 +000050 * Get a value from the fdt and format it to be set in the environment
51 */
Marek Vasut0282f9f2022-07-08 23:50:43 +020052static int fdt_value_env_set(const void *nodep, int len,
53 const char *var, int index)
Joe Hershbergerfc5abf02012-08-17 10:34:37 +000054{
Marek Vasut0282f9f2022-07-08 23:50:43 +020055 if (is_printable_string(nodep, len)) {
56 const char *nodec = (const char *)nodep;
57 int i;
58
59 /*
60 * Iterate over all members in stringlist and find the one at
61 * offset $index. If no such index exists, indicate failure.
62 */
Marek Vasut0b425492022-11-14 22:49:59 +010063 for (i = 0; i < len; ) {
64 if (index-- > 0) {
65 i += strlen(nodec) + 1;
66 nodec += strlen(nodec) + 1;
Marek Vasut0282f9f2022-07-08 23:50:43 +020067 continue;
Marek Vasut0b425492022-11-14 22:49:59 +010068 }
Marek Vasut0282f9f2022-07-08 23:50:43 +020069
Marek Vasut0b425492022-11-14 22:49:59 +010070 env_set(var, nodec);
Marek Vasut0282f9f2022-07-08 23:50:43 +020071 return 0;
72 }
73
74 return 1;
75 } else if (len == 4) {
Joe Hershbergerfc5abf02012-08-17 10:34:37 +000076 char buf[11];
77
Andreas Färber1a09cd22017-01-09 16:08:02 +010078 sprintf(buf, "0x%08X", fdt32_to_cpu(*(fdt32_t *)nodep));
Simon Glass6a38e412017-08-03 12:22:09 -060079 env_set(var, buf);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +000080 } else if (len%4 == 0 && len <= 20) {
81 /* Needed to print things like sha1 hashes. */
82 char buf[41];
83 int i;
84
85 for (i = 0; i < len; i += sizeof(unsigned int))
86 sprintf(buf + (i * 2), "%08x",
87 *(unsigned int *)(nodep + i));
Simon Glass6a38e412017-08-03 12:22:09 -060088 env_set(var, buf);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +000089 } else {
90 printf("error: unprintable value\n");
91 return 1;
92 }
93 return 0;
94}
95
Heiko Schocherfefc7ee2018-11-15 06:06:06 +010096static const char * const fdt_member_table[] = {
97 "magic",
98 "totalsize",
99 "off_dt_struct",
100 "off_dt_strings",
101 "off_mem_rsvmap",
102 "version",
103 "last_comp_version",
104 "boot_cpuid_phys",
105 "size_dt_strings",
106 "size_dt_struct",
107};
108
Simon Glassed38aef2020-05-10 11:40:03 -0600109static int fdt_get_header_value(int argc, char *const argv[])
Heiko Schocherfefc7ee2018-11-15 06:06:06 +0100110{
111 fdt32_t *fdtp = (fdt32_t *)working_fdt;
112 ulong val;
113 int i;
114
115 if (argv[2][0] != 'g')
116 return CMD_RET_FAILURE;
117
118 for (i = 0; i < ARRAY_SIZE(fdt_member_table); i++) {
119 if (strcmp(fdt_member_table[i], argv[4]))
120 continue;
121
122 val = fdt32_to_cpu(fdtp[i]);
123 env_set_hex(argv[3], val);
124 return CMD_RET_SUCCESS;
125 }
126
127 return CMD_RET_FAILURE;
128}
129
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000130/*
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400131 * Flattened Device Tree command, see the help for parameter definitions.
132 */
Simon Glassed38aef2020-05-10 11:40:03 -0600133static int do_fdt(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400134{
Wolfgang Denk3b683112010-07-17 01:06:04 +0200135 if (argc < 2)
Simon Glassa06dfc72011-12-10 08:44:01 +0000136 return CMD_RET_USAGE;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400137
Simon Glasse4647a12021-07-21 14:55:25 -0600138 /* fdt addr: Set the address of the fdt */
Maxime Ripard09caa012016-07-05 10:26:34 +0200139 if (strncmp(argv[1], "ad", 2) == 0) {
Kumar Gala9f4e7e42008-08-15 08:24:39 -0500140 unsigned long addr;
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000141 int control = 0;
Peter Hoyesfbbaa592022-03-31 11:53:22 +0100142 int quiet = 0;
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000143 struct fdt_header *blob;
Simon Glasse4647a12021-07-21 14:55:25 -0600144
145 /* Set the address [and length] of the fdt */
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000146 argc -= 2;
147 argv += 2;
Peter Hoyesfbbaa592022-03-31 11:53:22 +0100148 while (argc > 0 && **argv == '-') {
149 char *arg = *argv;
150
151 while (*++arg) {
152 switch (*arg) {
153 case 'c':
154 control = 1;
155 break;
156 case 'q':
157 quiet = 1;
158 break;
159 default:
160 return CMD_RET_USAGE;
161 }
162 }
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000163 argc--;
164 argv++;
165 }
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000166 if (argc == 0) {
167 if (control)
168 blob = (struct fdt_header *)gd->fdt_blob;
169 else
170 blob = working_fdt;
171 if (!blob || !fdt_valid(&blob))
Kumar Gala708a18b2008-08-15 08:24:35 -0500172 return 1;
Simon Glasseedc9222021-07-21 14:55:26 -0600173 printf("%s fdt: %08lx\n",
174 control ? "Control" : "Working",
Joe Hershberger6256dcc2015-02-04 21:56:54 -0600175 control ? (ulong)map_to_sysmem(blob) :
Simon Glasseedc9222021-07-21 14:55:26 -0600176 env_get_hex("fdtaddr", 0));
Kumar Gala708a18b2008-08-15 08:24:35 -0500177 return 0;
178 }
179
Simon Glass3ff49ec2021-07-24 09:03:29 -0600180 addr = hextoul(argv[0], NULL);
Simon Glassb7fc7102013-04-20 08:42:45 +0000181 blob = map_sysmem(addr, 0);
Peter Hoyesfbbaa592022-03-31 11:53:22 +0100182 if ((quiet && fdt_check_header(blob)) ||
183 (!quiet && !fdt_valid(&blob)))
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400184 return 1;
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000185 if (control)
186 gd->fdt_blob = blob;
187 else
Joe Hershberger3d4ea4c2015-02-04 21:56:53 -0600188 set_working_fdt_addr(addr);
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400189
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000190 if (argc >= 2) {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400191 int len;
192 int err;
Simon Glasse4647a12021-07-21 14:55:25 -0600193
194 /* Optional new length */
Simon Glass3ff49ec2021-07-24 09:03:29 -0600195 len = hextoul(argv[1], NULL);
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000196 if (len < fdt_totalsize(blob)) {
Peter Hoyesfbbaa592022-03-31 11:53:22 +0100197 if (!quiet)
198 printf("New length %d < existing length %d, ignoring\n",
199 len, fdt_totalsize(blob));
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400200 } else {
Simon Glasse4647a12021-07-21 14:55:25 -0600201 /* Open in place with a new length */
Simon Glass0bfc4cc2013-04-20 08:42:44 +0000202 err = fdt_open_into(blob, blob, len);
Peter Hoyesfbbaa592022-03-31 11:53:22 +0100203 if (!quiet && err != 0) {
Simon Glasse4647a12021-07-21 14:55:25 -0600204 printf("libfdt fdt_open_into(): %s\n",
205 fdt_strerror(err));
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400206 }
207 }
208 }
209
Marek Vasutaeccfee2012-09-05 08:34:44 +0200210 return CMD_RET_SUCCESS;
211 }
212
213 if (!working_fdt) {
Simon Glasse4647a12021-07-21 14:55:25 -0600214 puts("No FDT memory address configured. Please configure\n"
215 "the FDT address via \"fdt addr <address>\" command.\n"
216 "Aborting!\n");
Marek Vasutaeccfee2012-09-05 08:34:44 +0200217 return CMD_RET_FAILURE;
218 }
219
Wolfgang Denk3b683112010-07-17 01:06:04 +0200220 /*
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500221 * Move the working_fdt
Wolfgang Denk3b683112010-07-17 01:06:04 +0200222 */
Marek Vasutaeccfee2012-09-05 08:34:44 +0200223 if (strncmp(argv[1], "mo", 2) == 0) {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400224 struct fdt_header *newaddr;
225 int len;
226 int err;
227
Wolfgang Denk3b683112010-07-17 01:06:04 +0200228 if (argc < 4)
Simon Glassa06dfc72011-12-10 08:44:01 +0000229 return CMD_RET_USAGE;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400230
231 /*
232 * Set the address and length of the fdt.
233 */
Simon Glass3ff49ec2021-07-24 09:03:29 -0600234 working_fdt = (struct fdt_header *)hextoul(argv[2], NULL);
Simon Glass546b9a32013-04-20 08:42:42 +0000235 if (!fdt_valid(&working_fdt))
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400236 return 1;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400237
Simon Glass3ff49ec2021-07-24 09:03:29 -0600238 newaddr = (struct fdt_header *)hextoul(argv[3], NULL);
Gerald Van Baren4d223922007-04-25 22:47:15 -0400239
240 /*
241 * If the user specifies a length, use that. Otherwise use the
242 * current length.
243 */
244 if (argc <= 4) {
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500245 len = fdt_totalsize(working_fdt);
Gerald Van Baren4d223922007-04-25 22:47:15 -0400246 } else {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600247 len = hextoul(argv[4], NULL);
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500248 if (len < fdt_totalsize(working_fdt)) {
Gerald Van Barene596a162007-05-16 22:39:59 -0400249 printf ("New length 0x%X < existing length "
250 "0x%X, aborting.\n",
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500251 len, fdt_totalsize(working_fdt));
Gerald Van Baren4d223922007-04-25 22:47:15 -0400252 return 1;
253 }
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400254 }
255
256 /*
257 * Copy to the new location.
258 */
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500259 err = fdt_open_into(working_fdt, newaddr, len);
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400260 if (err != 0) {
Gerald Van Barene596a162007-05-16 22:39:59 -0400261 printf ("libfdt fdt_open_into(): %s\n",
262 fdt_strerror(err));
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400263 return 1;
264 }
Hiroyuki Yokoyama5f107b52018-10-18 20:43:54 +0200265 set_working_fdt_addr((ulong)newaddr);
Fabien Parenta0559ac2016-11-24 15:02:18 +0100266#ifdef CONFIG_OF_SYSTEM_SETUP
267 /* Call the board-specific fixup routine */
268 } else if (strncmp(argv[1], "sys", 3) == 0) {
269 int err = ft_system_setup(working_fdt, gd->bd);
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400270
Fabien Parenta0559ac2016-11-24 15:02:18 +0100271 if (err) {
272 printf("Failed to add system information to FDT: %s\n",
273 fdt_strerror(err));
274 return CMD_RET_FAILURE;
275 }
276#endif
Wolfgang Denk3b683112010-07-17 01:06:04 +0200277 /*
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400278 * Make a new node
Wolfgang Denk3b683112010-07-17 01:06:04 +0200279 */
Gerald Van Baren3b9d6292008-06-09 21:02:17 -0400280 } else if (strncmp(argv[1], "mk", 2) == 0) {
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400281 char *pathp; /* path */
282 char *nodep; /* new node to add */
283 int nodeoffset; /* node offset from libfdt */
284 int err;
285
286 /*
287 * Parameters: Node path, new node to be appended to the path.
288 */
Wolfgang Denk3b683112010-07-17 01:06:04 +0200289 if (argc < 4)
Simon Glassa06dfc72011-12-10 08:44:01 +0000290 return CMD_RET_USAGE;
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400291
292 pathp = argv[2];
293 nodep = argv[3];
294
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500295 nodeoffset = fdt_path_offset (working_fdt, pathp);
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400296 if (nodeoffset < 0) {
297 /*
298 * Not found or something else bad happened.
299 */
Kumar Galac8ab7052007-10-24 11:04:22 -0500300 printf ("libfdt fdt_path_offset() returned %s\n",
Gerald Van Baren1178d6a2007-05-21 23:27:16 -0400301 fdt_strerror(nodeoffset));
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400302 return 1;
303 }
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500304 err = fdt_add_subnode(working_fdt, nodeoffset, nodep);
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400305 if (err < 0) {
Gerald Van Barene596a162007-05-16 22:39:59 -0400306 printf ("libfdt fdt_add_subnode(): %s\n",
307 fdt_strerror(err));
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400308 return 1;
309 }
310
Wolfgang Denk3b683112010-07-17 01:06:04 +0200311 /*
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500312 * Set the value of a property in the working_fdt.
Wolfgang Denk3b683112010-07-17 01:06:04 +0200313 */
Tom Warrend2c6dc82020-03-26 15:20:44 -0700314 } else if (strncmp(argv[1], "se", 2) == 0) {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400315 char *pathp; /* path */
Gerald Van Barene596a162007-05-16 22:39:59 -0400316 char *prop; /* property */
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400317 int nodeoffset; /* node offset from libfdt */
Bernhard Messerklinger9b2664f2017-09-28 11:29:52 +0200318 static char data[SCRATCHPAD] __aligned(4);/* property storage */
Hannes Schmelzer98788612017-05-30 15:05:44 +0200319 const void *ptmp;
Gerald Van Barene596a162007-05-16 22:39:59 -0400320 int len; /* new length of the property */
321 int ret; /* return value */
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400322
323 /*
Gerald Van Barend91383a2008-01-05 14:52:04 -0500324 * Parameters: Node path, property, optional value.
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400325 */
Wolfgang Denk3b683112010-07-17 01:06:04 +0200326 if (argc < 4)
Simon Glassa06dfc72011-12-10 08:44:01 +0000327 return CMD_RET_USAGE;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400328
329 pathp = argv[2];
330 prop = argv[3];
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400331
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500332 nodeoffset = fdt_path_offset (working_fdt, pathp);
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400333 if (nodeoffset < 0) {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400334 /*
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400335 * Not found or something else bad happened.
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400336 */
Kumar Galac8ab7052007-10-24 11:04:22 -0500337 printf ("libfdt fdt_path_offset() returned %s\n",
Gerald Van Baren1178d6a2007-05-21 23:27:16 -0400338 fdt_strerror(nodeoffset));
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400339 return 1;
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400340 }
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400341
Hannes Schmelzer98788612017-05-30 15:05:44 +0200342 if (argc == 4) {
343 len = 0;
344 } else {
345 ptmp = fdt_getprop(working_fdt, nodeoffset, prop, &len);
346 if (len > SCRATCHPAD) {
347 printf("prop (%d) doesn't fit in scratchpad!\n",
348 len);
349 return 1;
350 }
Hannes Schmelzera99c0522017-08-18 14:41:14 +0200351 if (ptmp != NULL)
352 memcpy(data, ptmp, len);
353
Hannes Schmelzer98788612017-05-30 15:05:44 +0200354 ret = fdt_parse_prop(&argv[4], argc - 4, data, &len);
355 if (ret != 0)
356 return ret;
357 }
358
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500359 ret = fdt_setprop(working_fdt, nodeoffset, prop, data, len);
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400360 if (ret < 0) {
361 printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret));
362 return 1;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400363 }
364
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000365 /********************************************************************
366 * Get the value of a property in the working_fdt.
367 ********************************************************************/
368 } else if (argv[1][0] == 'g') {
369 char *subcmd; /* sub-command */
370 char *pathp; /* path */
371 char *prop; /* property */
372 char *var; /* variable to store result */
373 int nodeoffset; /* node offset from libfdt */
374 const void *nodep; /* property node pointer */
375 int len = 0; /* new length of the property */
376
377 /*
378 * Parameters: Node path, property, optional value.
379 */
380 if (argc < 5)
381 return CMD_RET_USAGE;
382
383 subcmd = argv[2];
384
385 if (argc < 6 && subcmd[0] != 's')
386 return CMD_RET_USAGE;
387
388 var = argv[3];
389 pathp = argv[4];
390 prop = argv[5];
391
392 nodeoffset = fdt_path_offset(working_fdt, pathp);
393 if (nodeoffset < 0) {
394 /*
395 * Not found or something else bad happened.
396 */
397 printf("libfdt fdt_path_offset() returned %s\n",
398 fdt_strerror(nodeoffset));
399 return 1;
400 }
401
402 if (subcmd[0] == 'n' || (subcmd[0] == 's' && argc == 5)) {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600403 int req_index = -1;
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000404 int startDepth = fdt_node_depth(
405 working_fdt, nodeoffset);
406 int curDepth = startDepth;
Simon Glass3ff49ec2021-07-24 09:03:29 -0600407 int cur_index = -1;
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000408 int nextNodeOffset = fdt_next_node(
409 working_fdt, nodeoffset, &curDepth);
410
411 if (subcmd[0] == 'n')
Simon Glass3ff49ec2021-07-24 09:03:29 -0600412 req_index = hextoul(argv[5], NULL);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000413
414 while (curDepth > startDepth) {
415 if (curDepth == startDepth + 1)
Simon Glass3ff49ec2021-07-24 09:03:29 -0600416 cur_index++;
417 if (subcmd[0] == 'n' &&
418 cur_index == req_index) {
Simon Glass6a38e412017-08-03 12:22:09 -0600419 const char *node_name;
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000420
Simon Glass6a38e412017-08-03 12:22:09 -0600421 node_name = fdt_get_name(working_fdt,
422 nextNodeOffset,
423 NULL);
424 env_set(var, node_name);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000425 return 0;
426 }
427 nextNodeOffset = fdt_next_node(
428 working_fdt, nextNodeOffset, &curDepth);
429 if (nextNodeOffset < 0)
430 break;
431 }
432 if (subcmd[0] == 's') {
433 /* get the num nodes at this level */
Simon Glass3ff49ec2021-07-24 09:03:29 -0600434 env_set_ulong(var, cur_index + 1);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000435 } else {
436 /* node index not found */
437 printf("libfdt node not found\n");
438 return 1;
439 }
440 } else {
441 nodep = fdt_getprop(
442 working_fdt, nodeoffset, prop, &len);
443 if (len == 0) {
444 /* no property value */
Simon Glass6a38e412017-08-03 12:22:09 -0600445 env_set(var, "");
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000446 return 0;
Simon Glass03746912017-06-07 10:28:41 -0600447 } else if (nodep && len > 0) {
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000448 if (subcmd[0] == 'v') {
Marek Vasut0282f9f2022-07-08 23:50:43 +0200449 int index = 0;
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000450 int ret;
451
Marek Vasut0282f9f2022-07-08 23:50:43 +0200452 if (argc == 7)
453 index = simple_strtoul(argv[6], NULL, 10);
454
Simon Glass6a38e412017-08-03 12:22:09 -0600455 ret = fdt_value_env_set(nodep, len,
Marek Vasut0282f9f2022-07-08 23:50:43 +0200456 var, index);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000457 if (ret != 0)
458 return ret;
459 } else if (subcmd[0] == 'a') {
460 /* Get address */
461 char buf[11];
462
Tom Rini1db8b532012-10-29 14:53:18 +0000463 sprintf(buf, "0x%p", nodep);
Simon Glass6a38e412017-08-03 12:22:09 -0600464 env_set(var, buf);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000465 } else if (subcmd[0] == 's') {
466 /* Get size */
467 char buf[11];
468
469 sprintf(buf, "0x%08X", len);
Simon Glass6a38e412017-08-03 12:22:09 -0600470 env_set(var, buf);
Joe Hershbergerfc5abf02012-08-17 10:34:37 +0000471 } else
472 return CMD_RET_USAGE;
473 return 0;
474 } else {
475 printf("libfdt fdt_getprop(): %s\n",
476 fdt_strerror(len));
477 return 1;
478 }
479 }
480
Wolfgang Denk3b683112010-07-17 01:06:04 +0200481 /*
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400482 * Print (recursive) / List (single level)
Wolfgang Denk3b683112010-07-17 01:06:04 +0200483 */
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400484 } else if ((argv[1][0] == 'p') || (argv[1][0] == 'l')) {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400485 int depth = MAX_LEVEL; /* how deep to print */
486 char *pathp; /* path */
Gerald Van Barene596a162007-05-16 22:39:59 -0400487 char *prop; /* property */
488 int ret; /* return value */
Kumar Gala51ab7f92007-10-25 16:15:07 -0500489 static char root[2] = "/";
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400490
491 /*
492 * list is an alias for print, but limited to 1 level
493 */
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400494 if (argv[1][0] == 'l') {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400495 depth = 1;
496 }
497
498 /*
499 * Get the starting path. The root node is an oddball,
500 * the offset is zero and has no name.
501 */
Kumar Gala51ab7f92007-10-25 16:15:07 -0500502 if (argc == 2)
503 pathp = root;
504 else
505 pathp = argv[2];
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400506 if (argc > 3)
507 prop = argv[3];
508 else
509 prop = NULL;
510
Gerald Van Barene596a162007-05-16 22:39:59 -0400511 ret = fdt_print(pathp, prop, depth);
512 if (ret != 0)
513 return ret;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400514
Wolfgang Denk3b683112010-07-17 01:06:04 +0200515 /*
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400516 * Remove a property/node
Wolfgang Denk3b683112010-07-17 01:06:04 +0200517 */
Gerald Van Baren3b9d6292008-06-09 21:02:17 -0400518 } else if (strncmp(argv[1], "rm", 2) == 0) {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400519 int nodeoffset; /* node offset from libfdt */
520 int err;
521
522 /*
523 * Get the path. The root node is an oddball, the offset
524 * is zero and has no name.
525 */
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500526 nodeoffset = fdt_path_offset (working_fdt, argv[2]);
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400527 if (nodeoffset < 0) {
528 /*
529 * Not found or something else bad happened.
530 */
Kumar Galac8ab7052007-10-24 11:04:22 -0500531 printf ("libfdt fdt_path_offset() returned %s\n",
Gerald Van Baren1178d6a2007-05-21 23:27:16 -0400532 fdt_strerror(nodeoffset));
Gerald Van Baren0ea55d22007-05-12 09:47:25 -0400533 return 1;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400534 }
535 /*
536 * Do the delete. A fourth parameter means delete a property,
537 * otherwise delete the node.
538 */
539 if (argc > 3) {
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500540 err = fdt_delprop(working_fdt, nodeoffset, argv[3]);
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400541 if (err < 0) {
Gerald Van Barene596a162007-05-16 22:39:59 -0400542 printf("libfdt fdt_delprop(): %s\n",
543 fdt_strerror(err));
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400544 return err;
545 }
546 } else {
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500547 err = fdt_del_node(working_fdt, nodeoffset);
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400548 if (err < 0) {
Gerald Van Barene596a162007-05-16 22:39:59 -0400549 printf("libfdt fdt_del_node(): %s\n",
550 fdt_strerror(err));
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400551 return err;
552 }
553 }
Kumar Galab79da7b2008-02-15 03:34:36 -0600554
Wolfgang Denk3b683112010-07-17 01:06:04 +0200555 /*
Kumar Galab79da7b2008-02-15 03:34:36 -0600556 * Display header info
Wolfgang Denk3b683112010-07-17 01:06:04 +0200557 */
Kumar Galab79da7b2008-02-15 03:34:36 -0600558 } else if (argv[1][0] == 'h') {
Heiko Schocherfefc7ee2018-11-15 06:06:06 +0100559 if (argc == 5)
560 return fdt_get_header_value(argc, argv);
561
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500562 u32 version = fdt_version(working_fdt);
563 printf("magic:\t\t\t0x%x\n", fdt_magic(working_fdt));
564 printf("totalsize:\t\t0x%x (%d)\n", fdt_totalsize(working_fdt),
565 fdt_totalsize(working_fdt));
566 printf("off_dt_struct:\t\t0x%x\n",
567 fdt_off_dt_struct(working_fdt));
568 printf("off_dt_strings:\t\t0x%x\n",
569 fdt_off_dt_strings(working_fdt));
570 printf("off_mem_rsvmap:\t\t0x%x\n",
571 fdt_off_mem_rsvmap(working_fdt));
Kumar Galab79da7b2008-02-15 03:34:36 -0600572 printf("version:\t\t%d\n", version);
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500573 printf("last_comp_version:\t%d\n",
574 fdt_last_comp_version(working_fdt));
Kumar Galab79da7b2008-02-15 03:34:36 -0600575 if (version >= 2)
576 printf("boot_cpuid_phys:\t0x%x\n",
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500577 fdt_boot_cpuid_phys(working_fdt));
Kumar Galab79da7b2008-02-15 03:34:36 -0600578 if (version >= 3)
579 printf("size_dt_strings:\t0x%x\n",
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500580 fdt_size_dt_strings(working_fdt));
Kumar Galab79da7b2008-02-15 03:34:36 -0600581 if (version >= 17)
582 printf("size_dt_struct:\t\t0x%x\n",
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500583 fdt_size_dt_struct(working_fdt));
584 printf("number mem_rsv:\t\t0x%x\n",
585 fdt_num_mem_rsv(working_fdt));
Kumar Galab79da7b2008-02-15 03:34:36 -0600586 printf("\n");
587
Wolfgang Denk3b683112010-07-17 01:06:04 +0200588 /*
Kumar Galab79da7b2008-02-15 03:34:36 -0600589 * Set boot cpu id
Wolfgang Denk3b683112010-07-17 01:06:04 +0200590 */
Gerald Van Baren3b9d6292008-06-09 21:02:17 -0400591 } else if (strncmp(argv[1], "boo", 3) == 0) {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600592 unsigned long tmp = hextoul(argv[2], NULL);
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500593 fdt_set_boot_cpuid_phys(working_fdt, tmp);
Kumar Galab79da7b2008-02-15 03:34:36 -0600594
Wolfgang Denk3b683112010-07-17 01:06:04 +0200595 /*
Kumar Galab79da7b2008-02-15 03:34:36 -0600596 * memory command
Wolfgang Denk3b683112010-07-17 01:06:04 +0200597 */
Gerald Van Baren3b9d6292008-06-09 21:02:17 -0400598 } else if (strncmp(argv[1], "me", 2) == 0) {
Kumar Galab79da7b2008-02-15 03:34:36 -0600599 uint64_t addr, size;
600 int err;
Heiko Schocher0f602e12009-12-03 11:21:21 +0100601 addr = simple_strtoull(argv[2], NULL, 16);
602 size = simple_strtoull(argv[3], NULL, 16);
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500603 err = fdt_fixup_memory(working_fdt, addr, size);
Kumar Galab79da7b2008-02-15 03:34:36 -0600604 if (err < 0)
605 return err;
606
Wolfgang Denk3b683112010-07-17 01:06:04 +0200607 /*
Kumar Galab79da7b2008-02-15 03:34:36 -0600608 * mem reserve commands
Wolfgang Denk3b683112010-07-17 01:06:04 +0200609 */
Gerald Van Baren3b9d6292008-06-09 21:02:17 -0400610 } else if (strncmp(argv[1], "rs", 2) == 0) {
Kumar Galab79da7b2008-02-15 03:34:36 -0600611 if (argv[2][0] == 'p') {
612 uint64_t addr, size;
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500613 int total = fdt_num_mem_rsv(working_fdt);
Kumar Galab79da7b2008-02-15 03:34:36 -0600614 int j, err;
615 printf("index\t\t start\t\t size\n");
616 printf("-------------------------------"
617 "-----------------\n");
618 for (j = 0; j < total; j++) {
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500619 err = fdt_get_mem_rsv(working_fdt, j, &addr, &size);
Kumar Galab79da7b2008-02-15 03:34:36 -0600620 if (err < 0) {
621 printf("libfdt fdt_get_mem_rsv(): %s\n",
622 fdt_strerror(err));
623 return err;
624 }
625 printf(" %x\t%08x%08x\t%08x%08x\n", j,
626 (u32)(addr >> 32),
627 (u32)(addr & 0xffffffff),
628 (u32)(size >> 32),
629 (u32)(size & 0xffffffff));
630 }
631 } else if (argv[2][0] == 'a') {
632 uint64_t addr, size;
633 int err;
Kumar Galab79da7b2008-02-15 03:34:36 -0600634 addr = simple_strtoull(argv[3], NULL, 16);
635 size = simple_strtoull(argv[4], NULL, 16);
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500636 err = fdt_add_mem_rsv(working_fdt, addr, size);
Kumar Galab79da7b2008-02-15 03:34:36 -0600637
638 if (err < 0) {
639 printf("libfdt fdt_add_mem_rsv(): %s\n",
640 fdt_strerror(err));
641 return err;
642 }
643 } else if (argv[2][0] == 'd') {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600644 unsigned long idx = hextoul(argv[3], NULL);
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500645 int err = fdt_del_mem_rsv(working_fdt, idx);
Kumar Galab79da7b2008-02-15 03:34:36 -0600646
647 if (err < 0) {
648 printf("libfdt fdt_del_mem_rsv(): %s\n",
649 fdt_strerror(err));
650 return err;
651 }
652 } else {
653 /* Unrecognized command */
Simon Glassa06dfc72011-12-10 08:44:01 +0000654 return CMD_RET_USAGE;
Kumar Galab79da7b2008-02-15 03:34:36 -0600655 }
Kim Phillipsbd9d1152007-07-17 13:57:04 -0500656 }
Gerald Van Baren5606a362007-06-25 23:25:28 -0400657#ifdef CONFIG_OF_BOARD_SETUP
Kim Phillipsbd9d1152007-07-17 13:57:04 -0500658 /* Call the board-specific fixup routine */
Simon Glass406ba622014-10-23 18:58:48 -0600659 else if (strncmp(argv[1], "boa", 3) == 0) {
660 int err = ft_board_setup(working_fdt, gd->bd);
661
662 if (err) {
663 printf("Failed to update board information in FDT: %s\n",
664 fdt_strerror(err));
665 return CMD_RET_FAILURE;
666 }
Tom Rini84c0f692021-09-12 20:32:32 -0400667#ifdef CONFIG_ARCH_KEYSTONE
Nicholas Faustinie5fb7862018-10-03 12:58:48 +0200668 ft_board_setup_ex(working_fdt, gd->bd);
669#endif
Simon Glass406ba622014-10-23 18:58:48 -0600670 }
Gerald Van Baren5606a362007-06-25 23:25:28 -0400671#endif
Kim Phillipsbd9d1152007-07-17 13:57:04 -0500672 /* Create a chosen node */
Heiko Schocherfce16b92014-03-03 12:19:24 +0100673 else if (strncmp(argv[1], "cho", 3) == 0) {
Kumar Galafb5dcd52008-08-15 08:24:34 -0500674 unsigned long initrd_start = 0, initrd_end = 0;
675
Wolfgang Denk3b683112010-07-17 01:06:04 +0200676 if ((argc != 2) && (argc != 4))
Simon Glassa06dfc72011-12-10 08:44:01 +0000677 return CMD_RET_USAGE;
Kumar Galafb5dcd52008-08-15 08:24:34 -0500678
679 if (argc == 4) {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600680 initrd_start = hextoul(argv[2], NULL);
Sean Anderson86b6f472022-03-22 16:59:21 -0400681 initrd_end = initrd_start + hextoul(argv[3], NULL) - 1;
Kumar Galafb5dcd52008-08-15 08:24:34 -0500682 }
683
Masahiro Yamada451c2042014-04-18 17:41:00 +0900684 fdt_chosen(working_fdt);
Masahiro Yamada5b114892014-04-18 17:40:59 +0900685 fdt_initrd(working_fdt, initrd_start, initrd_end);
Heiko Schocherfce16b92014-03-03 12:19:24 +0100686
687#if defined(CONFIG_FIT_SIGNATURE)
688 } else if (strncmp(argv[1], "che", 3) == 0) {
689 int cfg_noffset;
690 int ret;
691 unsigned long addr;
692 struct fdt_header *blob;
693
694 if (!working_fdt)
695 return CMD_RET_FAILURE;
696
697 if (argc > 2) {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600698 addr = hextoul(argv[2], NULL);
Heiko Schocherfce16b92014-03-03 12:19:24 +0100699 blob = map_sysmem(addr, 0);
700 } else {
701 blob = (struct fdt_header *)gd->fdt_blob;
702 }
703 if (!fdt_valid(&blob))
704 return 1;
705
706 gd->fdt_blob = blob;
707 cfg_noffset = fit_conf_get_node(working_fdt, NULL);
708 if (!cfg_noffset) {
709 printf("Could not find configuration node: %s\n",
710 fdt_strerror(cfg_noffset));
711 return CMD_RET_FAILURE;
712 }
713
714 ret = fit_config_verify(working_fdt, cfg_noffset);
Simon Glass5da42d92014-06-12 07:24:45 -0600715 if (ret == 0)
Heiko Schocherfce16b92014-03-03 12:19:24 +0100716 return CMD_RET_SUCCESS;
717 else
718 return CMD_RET_FAILURE;
719#endif
720
Kumar Gala58911df2008-08-15 08:24:44 -0500721 }
Maxime Ripard5a680aa2016-07-05 10:26:45 +0200722#ifdef CONFIG_OF_LIBFDT_OVERLAY
723 /* apply an overlay */
724 else if (strncmp(argv[1], "ap", 2) == 0) {
725 unsigned long addr;
726 struct fdt_header *blob;
Stefan Agnerfed14d02016-12-20 15:58:45 +0100727 int ret;
Maxime Ripard5a680aa2016-07-05 10:26:45 +0200728
729 if (argc != 3)
730 return CMD_RET_USAGE;
731
732 if (!working_fdt)
733 return CMD_RET_FAILURE;
734
Simon Glass3ff49ec2021-07-24 09:03:29 -0600735 addr = hextoul(argv[2], NULL);
Maxime Ripard5a680aa2016-07-05 10:26:45 +0200736 blob = map_sysmem(addr, 0);
737 if (!fdt_valid(&blob))
738 return CMD_RET_FAILURE;
739
Pantelis Antonioud9456a42017-09-04 23:12:12 +0300740 /* apply method prints messages on error */
741 ret = fdt_overlay_apply_verbose(working_fdt, blob);
742 if (ret)
Maxime Ripard5a680aa2016-07-05 10:26:45 +0200743 return CMD_RET_FAILURE;
744 }
745#endif
Kumar Gala58911df2008-08-15 08:24:44 -0500746 /* resize the fdt */
747 else if (strncmp(argv[1], "re", 2) == 0) {
Hannes Schmelzerd3dbac82016-09-20 18:10:43 +0200748 uint extrasize;
749 if (argc > 2)
Simon Glass3ff49ec2021-07-24 09:03:29 -0600750 extrasize = hextoul(argv[2], NULL);
Hannes Schmelzerd3dbac82016-09-20 18:10:43 +0200751 else
752 extrasize = 0;
753 fdt_shrink_to_minimum(working_fdt, extrasize);
Kumar Gala58911df2008-08-15 08:24:44 -0500754 }
755 else {
Kim Phillipsbd9d1152007-07-17 13:57:04 -0500756 /* Unrecognized command */
Simon Glassa06dfc72011-12-10 08:44:01 +0000757 return CMD_RET_USAGE;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400758 }
759
760 return 0;
761}
762
Gerald Van Barene596a162007-05-16 22:39:59 -0400763/****************************************************************************/
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400764
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400765/*
Gerald Van Barene596a162007-05-16 22:39:59 -0400766 * Parse the user's input, partially heuristic. Valid formats:
Andy Fleming46891472008-03-31 20:45:56 -0500767 * <0x00112233 4 05> - an array of cells. Numbers follow standard
Wolfgang Denka1be4762008-05-20 16:00:29 +0200768 * C conventions.
Gerald Van Barene596a162007-05-16 22:39:59 -0400769 * [00 11 22 .. nn] - byte stream
770 * "string" - If the the value doesn't start with "<" or "[", it is
771 * treated as a string. Note that the quotes are
772 * stripped by the parser before we get the string.
Andy Fleming46891472008-03-31 20:45:56 -0500773 * newval: An array of strings containing the new property as specified
Wolfgang Denka1be4762008-05-20 16:00:29 +0200774 * on the command line
Andy Fleming46891472008-03-31 20:45:56 -0500775 * count: The number of strings in the array
776 * data: A bytestream to be placed in the property
777 * len: The length of the resulting bytestream
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400778 */
Wolfgang Denk6262d0212010-06-28 22:00:46 +0200779static int fdt_parse_prop(char * const *newval, int count, char *data, int *len)
Gerald Van Barene596a162007-05-16 22:39:59 -0400780{
781 char *cp; /* temporary char pointer */
Andy Fleming46891472008-03-31 20:45:56 -0500782 char *newp; /* temporary newval char pointer */
Gerald Van Barene596a162007-05-16 22:39:59 -0400783 unsigned long tmp; /* holds converted values */
Andy Fleming46891472008-03-31 20:45:56 -0500784 int stridx = 0;
Gerald Van Barene596a162007-05-16 22:39:59 -0400785
Andy Fleming46891472008-03-31 20:45:56 -0500786 *len = 0;
787 newp = newval[0];
788
789 /* An array of cells */
790 if (*newp == '<') {
791 newp++;
792 while ((*newp != '>') && (stridx < count)) {
793 /*
794 * Keep searching until we find that last ">"
795 * That way users don't have to escape the spaces
796 */
797 if (*newp == '\0') {
798 newp = newval[++stridx];
799 continue;
800 }
801
802 cp = newp;
803 tmp = simple_strtoul(cp, &newp, 0);
Hannes Schmelzer98788612017-05-30 15:05:44 +0200804 if (*cp != '?')
805 *(fdt32_t *)data = cpu_to_fdt32(tmp);
806 else
807 newp++;
808
Andy Fleming46891472008-03-31 20:45:56 -0500809 data += 4;
810 *len += 4;
811
812 /* If the ptr didn't advance, something went wrong */
813 if ((newp - cp) <= 0) {
Gerald Van Barene596a162007-05-16 22:39:59 -0400814 printf("Sorry, I could not convert \"%s\"\n",
815 cp);
816 return 1;
817 }
Andy Fleming46891472008-03-31 20:45:56 -0500818
819 while (*newp == ' ')
820 newp++;
Gerald Van Barene596a162007-05-16 22:39:59 -0400821 }
Andy Fleming46891472008-03-31 20:45:56 -0500822
823 if (*newp != '>') {
824 printf("Unexpected character '%c'\n", *newp);
Gerald Van Barene596a162007-05-16 22:39:59 -0400825 return 1;
826 }
Andy Fleming46891472008-03-31 20:45:56 -0500827 } else if (*newp == '[') {
Gerald Van Barene596a162007-05-16 22:39:59 -0400828 /*
829 * Byte stream. Convert the values.
830 */
Andy Fleming46891472008-03-31 20:45:56 -0500831 newp++;
Ken MacLeodd028afa2009-09-11 15:16:18 -0500832 while ((stridx < count) && (*newp != ']')) {
Andy Fleming46891472008-03-31 20:45:56 -0500833 while (*newp == ' ')
834 newp++;
Ken MacLeodd028afa2009-09-11 15:16:18 -0500835 if (*newp == '\0') {
Andy Fleming46891472008-03-31 20:45:56 -0500836 newp = newval[++stridx];
Ken MacLeodd028afa2009-09-11 15:16:18 -0500837 continue;
838 }
839 if (!isxdigit(*newp))
840 break;
Simon Glass3ff49ec2021-07-24 09:03:29 -0600841 tmp = hextoul(newp, &newp);
Ken MacLeodd028afa2009-09-11 15:16:18 -0500842 *data++ = tmp & 0xFF;
843 *len = *len + 1;
Gerald Van Barene596a162007-05-16 22:39:59 -0400844 }
Andy Fleming46891472008-03-31 20:45:56 -0500845 if (*newp != ']') {
Andrew Klossnere4ad4542008-07-07 06:41:14 -0700846 printf("Unexpected character '%c'\n", *newp);
Gerald Van Barene596a162007-05-16 22:39:59 -0400847 return 1;
848 }
849 } else {
850 /*
Ken MacLeodd028afa2009-09-11 15:16:18 -0500851 * Assume it is one or more strings. Copy it into our
852 * data area for convenience (including the
853 * terminating '\0's).
Gerald Van Barene596a162007-05-16 22:39:59 -0400854 */
Andy Fleming46891472008-03-31 20:45:56 -0500855 while (stridx < count) {
Ken MacLeodd028afa2009-09-11 15:16:18 -0500856 size_t length = strlen(newp) + 1;
Andy Fleming46891472008-03-31 20:45:56 -0500857 strcpy(data, newp);
Ken MacLeodd028afa2009-09-11 15:16:18 -0500858 data += length;
859 *len += length;
Andy Fleming46891472008-03-31 20:45:56 -0500860 newp = newval[++stridx];
861 }
Gerald Van Barene596a162007-05-16 22:39:59 -0400862 }
863 return 0;
864}
865
866/****************************************************************************/
867
868/*
869 * Heuristic to guess if this is a string or concatenated strings.
870 */
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400871
872static int is_printable_string(const void *data, int len)
873{
874 const char *s = data;
875
876 /* zero length is not */
877 if (len == 0)
878 return 0;
879
Joe Hershbergerea2243b2012-08-17 10:34:38 +0000880 /* must terminate with zero or '\n' */
881 if (s[len - 1] != '\0' && s[len - 1] != '\n')
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400882 return 0;
883
884 /* printable or a null byte (concatenated strings) */
Joe Hershbergerea2243b2012-08-17 10:34:38 +0000885 while (((*s == '\0') || isprint(*s) || isspace(*s)) && (len > 0)) {
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400886 /*
887 * If we see a null, there are three possibilities:
888 * 1) If len == 1, it is the end of the string, printable
889 * 2) Next character also a null, not printable.
890 * 3) Next character not a null, continue to check.
891 */
892 if (s[0] == '\0') {
893 if (len == 1)
894 return 1;
895 if (s[1] == '\0')
896 return 0;
897 }
898 s++;
899 len--;
900 }
901
902 /* Not the null termination, or not done yet: not printable */
903 if (*s != '\0' || (len != 0))
904 return 0;
905
906 return 1;
907}
908
Gerald Van Barene596a162007-05-16 22:39:59 -0400909
910/*
911 * Print the property in the best format, a heuristic guess. Print as
912 * a string, concatenated strings, a byte, word, double word, or (if all
913 * else fails) it is printed as a stream of bytes.
914 */
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400915static void print_data(const void *data, int len)
916{
917 int j;
Heinrich Schuchardt1a5f58d2020-06-19 19:45:55 +0200918 const char *env_max_dump;
919 ulong max_dump = ULONG_MAX;
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400920
921 /* no data, don't print */
922 if (len == 0)
923 return;
924
Heinrich Schuchardt1a5f58d2020-06-19 19:45:55 +0200925 env_max_dump = env_get("fdt_max_dump");
926 if (env_max_dump)
Simon Glass3ff49ec2021-07-24 09:03:29 -0600927 max_dump = hextoul(env_max_dump, NULL);
Heinrich Schuchardt1a5f58d2020-06-19 19:45:55 +0200928
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400929 /*
930 * It is a string, but it may have multiple strings (embedded '\0's).
931 */
932 if (is_printable_string(data, len)) {
933 puts("\"");
934 j = 0;
935 while (j < len) {
936 if (j > 0)
937 puts("\", \"");
938 puts(data);
939 j += strlen(data) + 1;
940 data += strlen(data) + 1;
941 }
942 puts("\"");
943 return;
944 }
945
Andy Fleming46891472008-03-31 20:45:56 -0500946 if ((len %4) == 0) {
Heinrich Schuchardt1a5f58d2020-06-19 19:45:55 +0200947 if (len > max_dump)
Tom Rini1db8b532012-10-29 14:53:18 +0000948 printf("* 0x%p [0x%08x]", data, len);
Joe Hershbergerf72c6922012-08-17 10:34:36 +0000949 else {
Kim Phillipsdc00a682012-10-29 13:34:31 +0000950 const __be32 *p;
Andy Fleming46891472008-03-31 20:45:56 -0500951
Joe Hershbergerf72c6922012-08-17 10:34:36 +0000952 printf("<");
953 for (j = 0, p = data; j < len/4; j++)
954 printf("0x%08x%s", fdt32_to_cpu(p[j]),
955 j < (len/4 - 1) ? " " : "");
956 printf(">");
957 }
Andy Fleming46891472008-03-31 20:45:56 -0500958 } else { /* anything else... hexdump */
Heinrich Schuchardt1a5f58d2020-06-19 19:45:55 +0200959 if (len > max_dump)
Tom Rini1db8b532012-10-29 14:53:18 +0000960 printf("* 0x%p [0x%08x]", data, len);
Joe Hershbergerf72c6922012-08-17 10:34:36 +0000961 else {
962 const u8 *s;
Andy Fleming46891472008-03-31 20:45:56 -0500963
Joe Hershbergerf72c6922012-08-17 10:34:36 +0000964 printf("[");
965 for (j = 0, s = data; j < len; j++)
966 printf("%02x%s", s[j], j < len - 1 ? " " : "");
967 printf("]");
968 }
Gerald Van Barenade8ef42007-03-31 12:22:10 -0400969 }
Gerald Van Barene596a162007-05-16 22:39:59 -0400970}
971
972/****************************************************************************/
973
974/*
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500975 * Recursively print (a portion of) the working_fdt. The depth parameter
Gerald Van Barene596a162007-05-16 22:39:59 -0400976 * determines how deeply nested the fdt is printed.
977 */
Kumar Gala1e386af2007-11-21 14:07:46 -0600978static int fdt_print(const char *pathp, char *prop, int depth)
Gerald Van Barene596a162007-05-16 22:39:59 -0400979{
Gerald Van Barene596a162007-05-16 22:39:59 -0400980 static char tabs[MAX_LEVEL+1] =
981 "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"
982 "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
Kumar Gala1e386af2007-11-21 14:07:46 -0600983 const void *nodep; /* property node pointer */
Gerald Van Barene596a162007-05-16 22:39:59 -0400984 int nodeoffset; /* node offset from libfdt */
985 int nextoffset; /* next node offset from libfdt */
986 uint32_t tag; /* tag */
987 int len; /* length of the property */
988 int level = 0; /* keep track of nesting level */
Gerald Van Bareneb999ee2007-11-22 17:23:23 -0500989 const struct fdt_property *fdt_prop;
Gerald Van Barene596a162007-05-16 22:39:59 -0400990
Kim Phillipsf3a42e22008-06-10 11:06:17 -0500991 nodeoffset = fdt_path_offset (working_fdt, pathp);
Gerald Van Barene596a162007-05-16 22:39:59 -0400992 if (nodeoffset < 0) {
993 /*
994 * Not found or something else bad happened.
995 */
Kumar Galac8ab7052007-10-24 11:04:22 -0500996 printf ("libfdt fdt_path_offset() returned %s\n",
Gerald Van Baren1178d6a2007-05-21 23:27:16 -0400997 fdt_strerror(nodeoffset));
Gerald Van Barene596a162007-05-16 22:39:59 -0400998 return 1;
999 }
1000 /*
1001 * The user passed in a property as well as node path.
1002 * Print only the given property and then return.
1003 */
1004 if (prop) {
Kim Phillipsf3a42e22008-06-10 11:06:17 -05001005 nodep = fdt_getprop (working_fdt, nodeoffset, prop, &len);
Gerald Van Barene596a162007-05-16 22:39:59 -04001006 if (len == 0) {
1007 /* no property value */
1008 printf("%s %s\n", pathp, prop);
1009 return 0;
Simon Glass4bc73ef2017-06-07 10:28:42 -06001010 } else if (nodep && len > 0) {
Gerald Van Barenfc1a1092007-11-23 19:43:20 -05001011 printf("%s = ", prop);
Gerald Van Barene596a162007-05-16 22:39:59 -04001012 print_data (nodep, len);
1013 printf("\n");
1014 return 0;
1015 } else {
1016 printf ("libfdt fdt_getprop(): %s\n",
1017 fdt_strerror(len));
1018 return 1;
1019 }
1020 }
1021
1022 /*
1023 * The user passed in a node path and no property,
1024 * print the node and all subnodes.
1025 */
Gerald Van Barene596a162007-05-16 22:39:59 -04001026 while(level >= 0) {
Kim Phillipsf3a42e22008-06-10 11:06:17 -05001027 tag = fdt_next_tag(working_fdt, nodeoffset, &nextoffset);
Gerald Van Barene596a162007-05-16 22:39:59 -04001028 switch(tag) {
1029 case FDT_BEGIN_NODE:
Kim Phillipsf3a42e22008-06-10 11:06:17 -05001030 pathp = fdt_get_name(working_fdt, nodeoffset, NULL);
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001031 if (level <= depth) {
1032 if (pathp == NULL)
1033 pathp = "/* NULL pointer error */";
1034 if (*pathp == '\0')
1035 pathp = "/"; /* root is nameless */
Gerald Van Barene596a162007-05-16 22:39:59 -04001036 printf("%s%s {\n",
1037 &tabs[MAX_LEVEL - level], pathp);
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001038 }
Gerald Van Barene596a162007-05-16 22:39:59 -04001039 level++;
Gerald Van Barene596a162007-05-16 22:39:59 -04001040 if (level >= MAX_LEVEL) {
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001041 printf("Nested too deep, aborting.\n");
Gerald Van Barene596a162007-05-16 22:39:59 -04001042 return 1;
1043 }
1044 break;
1045 case FDT_END_NODE:
1046 level--;
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001047 if (level <= depth)
Gerald Van Barene596a162007-05-16 22:39:59 -04001048 printf("%s};\n", &tabs[MAX_LEVEL - level]);
1049 if (level == 0) {
1050 level = -1; /* exit the loop */
1051 }
1052 break;
1053 case FDT_PROP:
Kim Phillipsf3a42e22008-06-10 11:06:17 -05001054 fdt_prop = fdt_offset_ptr(working_fdt, nodeoffset,
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001055 sizeof(*fdt_prop));
Kim Phillipsf3a42e22008-06-10 11:06:17 -05001056 pathp = fdt_string(working_fdt,
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001057 fdt32_to_cpu(fdt_prop->nameoff));
1058 len = fdt32_to_cpu(fdt_prop->len);
1059 nodep = fdt_prop->data;
Gerald Van Barene596a162007-05-16 22:39:59 -04001060 if (len < 0) {
1061 printf ("libfdt fdt_getprop(): %s\n",
1062 fdt_strerror(len));
1063 return 1;
1064 } else if (len == 0) {
1065 /* the property has no value */
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001066 if (level <= depth)
Gerald Van Barene596a162007-05-16 22:39:59 -04001067 printf("%s%s;\n",
1068 &tabs[MAX_LEVEL - level],
1069 pathp);
1070 } else {
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001071 if (level <= depth) {
Gerald Van Barenfc1a1092007-11-23 19:43:20 -05001072 printf("%s%s = ",
Gerald Van Barene596a162007-05-16 22:39:59 -04001073 &tabs[MAX_LEVEL - level],
1074 pathp);
1075 print_data (nodep, len);
1076 printf(";\n");
1077 }
1078 }
1079 break;
1080 case FDT_NOP:
Andrew Klossnere4ad4542008-07-07 06:41:14 -07001081 printf("%s/* NOP */\n", &tabs[MAX_LEVEL - level]);
Gerald Van Barene596a162007-05-16 22:39:59 -04001082 break;
1083 case FDT_END:
1084 return 1;
1085 default:
Gerald Van Bareneb999ee2007-11-22 17:23:23 -05001086 if (level <= depth)
Gerald Van Barene596a162007-05-16 22:39:59 -04001087 printf("Unknown tag 0x%08X\n", tag);
1088 return 1;
1089 }
1090 nodeoffset = nextoffset;
1091 }
1092 return 0;
Gerald Van Barenade8ef42007-03-31 12:22:10 -04001093}
Gerald Van Barenade8ef42007-03-31 12:22:10 -04001094
1095/********************************************************************/
Kim Phillipsdc00a682012-10-29 13:34:31 +00001096#ifdef CONFIG_SYS_LONGHELP
1097static char fdt_help_text[] =
Heinrich Schuchardt9696dbb2022-04-25 18:35:05 +02001098 "addr [-c] [-q] <addr> [<size>] - Set the [control] fdt location to <addr>\n"
Maxime Ripard5a680aa2016-07-05 10:26:45 +02001099#ifdef CONFIG_OF_LIBFDT_OVERLAY
1100 "fdt apply <addr> - Apply overlay to the DT\n"
1101#endif
Gerald Van Baren5606a362007-06-25 23:25:28 -04001102#ifdef CONFIG_OF_BOARD_SETUP
1103 "fdt boardsetup - Do board-specific set up\n"
1104#endif
Simon Glass6c0be912014-10-23 18:58:54 -06001105#ifdef CONFIG_OF_SYSTEM_SETUP
1106 "fdt systemsetup - Do system-specific set up\n"
1107#endif
Gerald Van Baren7655c092008-01-05 15:33:29 -05001108 "fdt move <fdt> <newaddr> <length> - Copy the fdt to <addr> and make it active\n"
Hannes Schmelzerd3dbac82016-09-20 18:10:43 +02001109 "fdt resize [<extrasize>] - Resize fdt to size + padding to 4k addr + some optional <extrasize> if needed\n"
Gerald Van Barenade8ef42007-03-31 12:22:10 -04001110 "fdt print <path> [<prop>] - Recursive print starting at <path>\n"
1111 "fdt list <path> [<prop>] - Print one level starting at <path>\n"
Marek Vasut0282f9f2022-07-08 23:50:43 +02001112 "fdt get value <var> <path> <prop> [<index>] - Get <property> and store in <var>\n"
1113 " In case of stringlist property, use optional <index>\n"
1114 " to select string within the stringlist. Default is 0.\n"
Joe Hershbergerfc5abf02012-08-17 10:34:37 +00001115 "fdt get name <var> <path> <index> - Get name of node <index> and store in <var>\n"
1116 "fdt get addr <var> <path> <prop> - Get start address of <property> and store in <var>\n"
1117 "fdt get size <var> <path> [<prop>] - Get size of [<property>] or num nodes and store in <var>\n"
Gerald Van Barenade8ef42007-03-31 12:22:10 -04001118 "fdt set <path> <prop> [<val>] - Set <property> [to <val>]\n"
1119 "fdt mknode <path> <node> - Create a new node after <path>\n"
1120 "fdt rm <path> [<prop>] - Delete the node or <property>\n"
Heiko Schocherfefc7ee2018-11-15 06:06:06 +01001121 "fdt header [get <var> <member>] - Display header info\n"
1122 " get - get header member <member> and store it in <var>\n"
Kumar Galab79da7b2008-02-15 03:34:36 -06001123 "fdt bootcpu <id> - Set boot cpuid\n"
1124 "fdt memory <addr> <size> - Add/Update memory node\n"
1125 "fdt rsvmem print - Show current mem reserves\n"
1126 "fdt rsvmem add <addr> <size> - Add a mem reserve\n"
1127 "fdt rsvmem delete <index> - Delete a mem reserves\n"
Sean Anderson86b6f472022-03-22 16:59:21 -04001128 "fdt chosen [<start> <size>] - Add/update the /chosen branch in the tree\n"
1129 " <start>/<size> - initrd start addr/size\n"
Heiko Schocherfce16b92014-03-03 12:19:24 +01001130#if defined(CONFIG_FIT_SIGNATURE)
1131 "fdt checksign [<addr>] - check FIT signature\n"
1132 " <start> - addr of key blob\n"
1133 " default gd->fdt_blob\n"
1134#endif
Robert P. J. Day8c60f922016-05-04 04:47:31 -04001135 "NOTE: Dereference aliases by omitting the leading '/', "
Kim Phillipsdc00a682012-10-29 13:34:31 +00001136 "e.g. fdt print ethernet0.";
1137#endif
1138
1139U_BOOT_CMD(
1140 fdt, 255, 0, do_fdt,
1141 "flattened device tree utility commands", fdt_help_text
Gerald Van Barenade8ef42007-03-31 12:22:10 -04001142);