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