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 | |
| 10 | #include <common.h> |
| 11 | #include <command.h> |
Simon Glass | 313112a | 2019-08-01 09:46:46 -0600 | [diff] [blame] | 12 | #include <env.h> |
Simon Glass | 2dc9c34 | 2020-05-10 11:40:01 -0600 | [diff] [blame] | 13 | #include <image.h> |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 14 | #include <linux/ctype.h> |
| 15 | #include <linux/types.h> |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 16 | #include <asm/global_data.h> |
Masahiro Yamada | 75f82d0 | 2018-03-05 01:20:11 +0900 | [diff] [blame] | 17 | #include <linux/libfdt.h> |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 18 | #include <fdt_support.h> |
Joe Hershberger | 65b905b | 2015-03-22 17:08:59 -0500 | [diff] [blame] | 19 | #include <mapmem.h> |
Simon Glass | b7fc710 | 2013-04-20 08:42:45 +0000 | [diff] [blame] | 20 | #include <asm/io.h> |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 21 | |
| 22 | #define MAX_LEVEL 32 /* how deeply nested we will go */ |
Gerald Van Baren | 5606a36 | 2007-06-25 23:25:28 -0400 | [diff] [blame] | 23 | #define SCRATCHPAD 1024 /* bytes of scratchpad memory */ |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 24 | |
| 25 | /* |
| 26 | * Global data (for the gd->bd) |
| 27 | */ |
| 28 | DECLARE_GLOBAL_DATA_PTR; |
| 29 | |
Wolfgang Denk | 6262d021 | 2010-06-28 22:00:46 +0200 | [diff] [blame] | 30 | 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] | 31 | static int fdt_print(const char *pathp, char *prop, int depth); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 32 | static int is_printable_string(const void *data, int len); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 33 | |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 34 | /* |
Gerald Van Baren | e81ce61 | 2008-06-10 22:15:58 -0400 | [diff] [blame] | 35 | * The working_fdt points to our working flattened device tree. |
| 36 | */ |
| 37 | struct fdt_header *working_fdt; |
| 38 | |
Joe Hershberger | 3d4ea4c | 2015-02-04 21:56:53 -0600 | [diff] [blame] | 39 | void set_working_fdt_addr(ulong addr) |
Kumar Gala | 9f4e7e4 | 2008-08-15 08:24:39 -0500 | [diff] [blame] | 40 | { |
Simon Glass | b7fc710 | 2013-04-20 08:42:45 +0000 | [diff] [blame] | 41 | void *buf; |
| 42 | |
Simon Glass | 84328cf | 2022-10-11 09:47:12 -0600 | [diff] [blame] | 43 | printf("Working FDT set to %lx\n", addr); |
Joe Hershberger | 3d4ea4c | 2015-02-04 21:56:53 -0600 | [diff] [blame] | 44 | buf = map_sysmem(addr, 0); |
Simon Glass | b7fc710 | 2013-04-20 08:42:45 +0000 | [diff] [blame] | 45 | working_fdt = buf; |
Simon Glass | 4d949a2 | 2017-08-03 12:22:10 -0600 | [diff] [blame] | 46 | env_set_hex("fdtaddr", addr); |
Kumar Gala | 9f4e7e4 | 2008-08-15 08:24:39 -0500 | [diff] [blame] | 47 | } |
| 48 | |
Gerald Van Baren | e81ce61 | 2008-06-10 22:15:58 -0400 | [diff] [blame] | 49 | /* |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 50 | * Get a value from the fdt and format it to be set in the environment |
| 51 | */ |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 52 | static int fdt_value_env_set(const void *nodep, int len, |
| 53 | const char *var, int index) |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 54 | { |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 55 | 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 Vasut | 0b42549 | 2022-11-14 22:49:59 +0100 | [diff] [blame] | 63 | for (i = 0; i < len; ) { |
| 64 | if (index-- > 0) { |
| 65 | i += strlen(nodec) + 1; |
| 66 | nodec += strlen(nodec) + 1; |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 67 | continue; |
Marek Vasut | 0b42549 | 2022-11-14 22:49:59 +0100 | [diff] [blame] | 68 | } |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 69 | |
Marek Vasut | 0b42549 | 2022-11-14 22:49:59 +0100 | [diff] [blame] | 70 | env_set(var, nodec); |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 71 | return 0; |
| 72 | } |
| 73 | |
| 74 | return 1; |
| 75 | } else if (len == 4) { |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 76 | char buf[11]; |
| 77 | |
Andreas Färber | 1a09cd2 | 2017-01-09 16:08:02 +0100 | [diff] [blame] | 78 | sprintf(buf, "0x%08X", fdt32_to_cpu(*(fdt32_t *)nodep)); |
Simon Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 79 | env_set(var, buf); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 80 | } 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 Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 88 | env_set(var, buf); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 89 | } else { |
| 90 | printf("error: unprintable value\n"); |
| 91 | return 1; |
| 92 | } |
| 93 | return 0; |
| 94 | } |
| 95 | |
Heiko Schocher | fefc7ee | 2018-11-15 06:06:06 +0100 | [diff] [blame] | 96 | static 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 Glass | ed38aef | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 109 | static int fdt_get_header_value(int argc, char *const argv[]) |
Heiko Schocher | fefc7ee | 2018-11-15 06:06:06 +0100 | [diff] [blame] | 110 | { |
| 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 Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 130 | /* |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 131 | * Flattened Device Tree command, see the help for parameter definitions. |
| 132 | */ |
Simon Glass | ed38aef | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 133 | 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] | 134 | { |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 135 | if (argc < 2) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 136 | return CMD_RET_USAGE; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 137 | |
Simon Glass | e4647a1 | 2021-07-21 14:55:25 -0600 | [diff] [blame] | 138 | /* fdt addr: Set the address of the fdt */ |
Maxime Ripard | 09caa01 | 2016-07-05 10:26:34 +0200 | [diff] [blame] | 139 | if (strncmp(argv[1], "ad", 2) == 0) { |
Kumar Gala | 9f4e7e4 | 2008-08-15 08:24:39 -0500 | [diff] [blame] | 140 | unsigned long addr; |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 141 | int control = 0; |
Peter Hoyes | fbbaa59 | 2022-03-31 11:53:22 +0100 | [diff] [blame] | 142 | int quiet = 0; |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 143 | struct fdt_header *blob; |
Simon Glass | e4647a1 | 2021-07-21 14:55:25 -0600 | [diff] [blame] | 144 | |
| 145 | /* Set the address [and length] of the fdt */ |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 146 | argc -= 2; |
| 147 | argv += 2; |
Peter Hoyes | fbbaa59 | 2022-03-31 11:53:22 +0100 | [diff] [blame] | 148 | 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 Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 163 | argc--; |
| 164 | argv++; |
| 165 | } |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 166 | 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 Gala | 708a18b | 2008-08-15 08:24:35 -0500 | [diff] [blame] | 172 | return 1; |
Simon Glass | eedc922 | 2021-07-21 14:55:26 -0600 | [diff] [blame] | 173 | printf("%s fdt: %08lx\n", |
| 174 | control ? "Control" : "Working", |
Joe Hershberger | 6256dcc | 2015-02-04 21:56:54 -0600 | [diff] [blame] | 175 | control ? (ulong)map_to_sysmem(blob) : |
Simon Glass | eedc922 | 2021-07-21 14:55:26 -0600 | [diff] [blame] | 176 | env_get_hex("fdtaddr", 0)); |
Kumar Gala | 708a18b | 2008-08-15 08:24:35 -0500 | [diff] [blame] | 177 | return 0; |
| 178 | } |
| 179 | |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 180 | addr = hextoul(argv[0], NULL); |
Simon Glass | b7fc710 | 2013-04-20 08:42:45 +0000 | [diff] [blame] | 181 | blob = map_sysmem(addr, 0); |
Peter Hoyes | fbbaa59 | 2022-03-31 11:53:22 +0100 | [diff] [blame] | 182 | if ((quiet && fdt_check_header(blob)) || |
| 183 | (!quiet && !fdt_valid(&blob))) |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 184 | return 1; |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 185 | if (control) |
| 186 | gd->fdt_blob = blob; |
| 187 | else |
Joe Hershberger | 3d4ea4c | 2015-02-04 21:56:53 -0600 | [diff] [blame] | 188 | set_working_fdt_addr(addr); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 189 | |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 190 | if (argc >= 2) { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 191 | int len; |
| 192 | int err; |
Simon Glass | e4647a1 | 2021-07-21 14:55:25 -0600 | [diff] [blame] | 193 | |
| 194 | /* Optional new length */ |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 195 | len = hextoul(argv[1], NULL); |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 196 | if (len < fdt_totalsize(blob)) { |
Peter Hoyes | fbbaa59 | 2022-03-31 11:53:22 +0100 | [diff] [blame] | 197 | if (!quiet) |
| 198 | printf("New length %d < existing length %d, ignoring\n", |
| 199 | len, fdt_totalsize(blob)); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 200 | } else { |
Simon Glass | e4647a1 | 2021-07-21 14:55:25 -0600 | [diff] [blame] | 201 | /* Open in place with a new length */ |
Simon Glass | 0bfc4cc | 2013-04-20 08:42:44 +0000 | [diff] [blame] | 202 | err = fdt_open_into(blob, blob, len); |
Peter Hoyes | fbbaa59 | 2022-03-31 11:53:22 +0100 | [diff] [blame] | 203 | if (!quiet && err != 0) { |
Simon Glass | e4647a1 | 2021-07-21 14:55:25 -0600 | [diff] [blame] | 204 | printf("libfdt fdt_open_into(): %s\n", |
| 205 | fdt_strerror(err)); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 206 | } |
| 207 | } |
| 208 | } |
| 209 | |
Marek Vasut | aeccfee | 2012-09-05 08:34:44 +0200 | [diff] [blame] | 210 | return CMD_RET_SUCCESS; |
| 211 | } |
| 212 | |
| 213 | if (!working_fdt) { |
Simon Glass | e4647a1 | 2021-07-21 14:55:25 -0600 | [diff] [blame] | 214 | puts("No FDT memory address configured. Please configure\n" |
| 215 | "the FDT address via \"fdt addr <address>\" command.\n" |
| 216 | "Aborting!\n"); |
Marek Vasut | aeccfee | 2012-09-05 08:34:44 +0200 | [diff] [blame] | 217 | return CMD_RET_FAILURE; |
| 218 | } |
| 219 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 220 | /* |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 221 | * Move the working_fdt |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 222 | */ |
Marek Vasut | aeccfee | 2012-09-05 08:34:44 +0200 | [diff] [blame] | 223 | if (strncmp(argv[1], "mo", 2) == 0) { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 224 | struct fdt_header *newaddr; |
| 225 | int len; |
| 226 | int err; |
| 227 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 228 | if (argc < 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 229 | return CMD_RET_USAGE; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 230 | |
| 231 | /* |
| 232 | * Set the address and length of the fdt. |
| 233 | */ |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 234 | working_fdt = (struct fdt_header *)hextoul(argv[2], NULL); |
Simon Glass | 546b9a3 | 2013-04-20 08:42:42 +0000 | [diff] [blame] | 235 | if (!fdt_valid(&working_fdt)) |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 236 | return 1; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 237 | |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 238 | newaddr = (struct fdt_header *)hextoul(argv[3], NULL); |
Gerald Van Baren | 4d22392 | 2007-04-25 22:47:15 -0400 | [diff] [blame] | 239 | |
| 240 | /* |
| 241 | * If the user specifies a length, use that. Otherwise use the |
| 242 | * current length. |
| 243 | */ |
| 244 | if (argc <= 4) { |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 245 | len = fdt_totalsize(working_fdt); |
Gerald Van Baren | 4d22392 | 2007-04-25 22:47:15 -0400 | [diff] [blame] | 246 | } else { |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 247 | len = hextoul(argv[4], NULL); |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 248 | if (len < fdt_totalsize(working_fdt)) { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 249 | printf ("New length 0x%X < existing length " |
| 250 | "0x%X, aborting.\n", |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 251 | len, fdt_totalsize(working_fdt)); |
Gerald Van Baren | 4d22392 | 2007-04-25 22:47:15 -0400 | [diff] [blame] | 252 | return 1; |
| 253 | } |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | /* |
| 257 | * Copy to the new location. |
| 258 | */ |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 259 | err = fdt_open_into(working_fdt, newaddr, len); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 260 | if (err != 0) { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 261 | printf ("libfdt fdt_open_into(): %s\n", |
| 262 | fdt_strerror(err)); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 263 | return 1; |
| 264 | } |
Hiroyuki Yokoyama | 5f107b5 | 2018-10-18 20:43:54 +0200 | [diff] [blame] | 265 | set_working_fdt_addr((ulong)newaddr); |
Fabien Parent | a0559ac | 2016-11-24 15:02:18 +0100 | [diff] [blame] | 266 | #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 Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 270 | |
Fabien Parent | a0559ac | 2016-11-24 15:02:18 +0100 | [diff] [blame] | 271 | 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 Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 277 | /* |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 278 | * Make a new node |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 279 | */ |
Gerald Van Baren | 3b9d629 | 2008-06-09 21:02:17 -0400 | [diff] [blame] | 280 | } else if (strncmp(argv[1], "mk", 2) == 0) { |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 281 | 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 Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 289 | if (argc < 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 290 | return CMD_RET_USAGE; |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 291 | |
| 292 | pathp = argv[2]; |
| 293 | nodep = argv[3]; |
| 294 | |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 295 | nodeoffset = fdt_path_offset (working_fdt, pathp); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 296 | if (nodeoffset < 0) { |
| 297 | /* |
| 298 | * Not found or something else bad happened. |
| 299 | */ |
Kumar Gala | c8ab705 | 2007-10-24 11:04:22 -0500 | [diff] [blame] | 300 | printf ("libfdt fdt_path_offset() returned %s\n", |
Gerald Van Baren | 1178d6a | 2007-05-21 23:27:16 -0400 | [diff] [blame] | 301 | fdt_strerror(nodeoffset)); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 302 | return 1; |
| 303 | } |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 304 | err = fdt_add_subnode(working_fdt, nodeoffset, nodep); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 305 | if (err < 0) { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 306 | printf ("libfdt fdt_add_subnode(): %s\n", |
| 307 | fdt_strerror(err)); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 308 | return 1; |
| 309 | } |
| 310 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 311 | /* |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 312 | * Set the value of a property in the working_fdt. |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 313 | */ |
Tom Warren | d2c6dc8 | 2020-03-26 15:20:44 -0700 | [diff] [blame] | 314 | } else if (strncmp(argv[1], "se", 2) == 0) { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 315 | char *pathp; /* path */ |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 316 | char *prop; /* property */ |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 317 | int nodeoffset; /* node offset from libfdt */ |
Bernhard Messerklinger | 9b2664f | 2017-09-28 11:29:52 +0200 | [diff] [blame] | 318 | static char data[SCRATCHPAD] __aligned(4);/* property storage */ |
Hannes Schmelzer | 9878861 | 2017-05-30 15:05:44 +0200 | [diff] [blame] | 319 | const void *ptmp; |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 320 | int len; /* new length of the property */ |
| 321 | int ret; /* return value */ |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 322 | |
| 323 | /* |
Gerald Van Baren | d91383a | 2008-01-05 14:52:04 -0500 | [diff] [blame] | 324 | * Parameters: Node path, property, optional value. |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 325 | */ |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 326 | if (argc < 4) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 327 | return CMD_RET_USAGE; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 328 | |
| 329 | pathp = argv[2]; |
| 330 | prop = argv[3]; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 331 | |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 332 | nodeoffset = fdt_path_offset (working_fdt, pathp); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 333 | if (nodeoffset < 0) { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 334 | /* |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 335 | * Not found or something else bad happened. |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 336 | */ |
Kumar Gala | c8ab705 | 2007-10-24 11:04:22 -0500 | [diff] [blame] | 337 | printf ("libfdt fdt_path_offset() returned %s\n", |
Gerald Van Baren | 1178d6a | 2007-05-21 23:27:16 -0400 | [diff] [blame] | 338 | fdt_strerror(nodeoffset)); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 339 | return 1; |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 340 | } |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 341 | |
Hannes Schmelzer | 9878861 | 2017-05-30 15:05:44 +0200 | [diff] [blame] | 342 | 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 Schmelzer | a99c052 | 2017-08-18 14:41:14 +0200 | [diff] [blame] | 351 | if (ptmp != NULL) |
| 352 | memcpy(data, ptmp, len); |
| 353 | |
Hannes Schmelzer | 9878861 | 2017-05-30 15:05:44 +0200 | [diff] [blame] | 354 | ret = fdt_parse_prop(&argv[4], argc - 4, data, &len); |
| 355 | if (ret != 0) |
| 356 | return ret; |
| 357 | } |
| 358 | |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 359 | ret = fdt_setprop(working_fdt, nodeoffset, prop, data, len); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 360 | if (ret < 0) { |
| 361 | printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret)); |
| 362 | return 1; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 363 | } |
| 364 | |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 365 | /******************************************************************** |
| 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 Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 403 | int req_index = -1; |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 404 | int startDepth = fdt_node_depth( |
| 405 | working_fdt, nodeoffset); |
| 406 | int curDepth = startDepth; |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 407 | int cur_index = -1; |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 408 | int nextNodeOffset = fdt_next_node( |
| 409 | working_fdt, nodeoffset, &curDepth); |
| 410 | |
| 411 | if (subcmd[0] == 'n') |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 412 | req_index = hextoul(argv[5], NULL); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 413 | |
| 414 | while (curDepth > startDepth) { |
| 415 | if (curDepth == startDepth + 1) |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 416 | cur_index++; |
| 417 | if (subcmd[0] == 'n' && |
| 418 | cur_index == req_index) { |
Simon Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 419 | const char *node_name; |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 420 | |
Simon Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 421 | node_name = fdt_get_name(working_fdt, |
| 422 | nextNodeOffset, |
| 423 | NULL); |
| 424 | env_set(var, node_name); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 425 | 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 Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 434 | env_set_ulong(var, cur_index + 1); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 435 | } 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 Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 445 | env_set(var, ""); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 446 | return 0; |
Simon Glass | 0374691 | 2017-06-07 10:28:41 -0600 | [diff] [blame] | 447 | } else if (nodep && len > 0) { |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 448 | if (subcmd[0] == 'v') { |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 449 | int index = 0; |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 450 | int ret; |
| 451 | |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 452 | if (argc == 7) |
| 453 | index = simple_strtoul(argv[6], NULL, 10); |
| 454 | |
Simon Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 455 | ret = fdt_value_env_set(nodep, len, |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 456 | var, index); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 457 | if (ret != 0) |
| 458 | return ret; |
| 459 | } else if (subcmd[0] == 'a') { |
| 460 | /* Get address */ |
| 461 | char buf[11]; |
| 462 | |
Tom Rini | 1db8b53 | 2012-10-29 14:53:18 +0000 | [diff] [blame] | 463 | sprintf(buf, "0x%p", nodep); |
Simon Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 464 | env_set(var, buf); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 465 | } else if (subcmd[0] == 's') { |
| 466 | /* Get size */ |
| 467 | char buf[11]; |
| 468 | |
| 469 | sprintf(buf, "0x%08X", len); |
Simon Glass | 6a38e41 | 2017-08-03 12:22:09 -0600 | [diff] [blame] | 470 | env_set(var, buf); |
Joe Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 471 | } 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 Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 481 | /* |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 482 | * Print (recursive) / List (single level) |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 483 | */ |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 484 | } else if ((argv[1][0] == 'p') || (argv[1][0] == 'l')) { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 485 | int depth = MAX_LEVEL; /* how deep to print */ |
| 486 | char *pathp; /* path */ |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 487 | char *prop; /* property */ |
| 488 | int ret; /* return value */ |
Kumar Gala | 51ab7f9 | 2007-10-25 16:15:07 -0500 | [diff] [blame] | 489 | static char root[2] = "/"; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 490 | |
| 491 | /* |
| 492 | * list is an alias for print, but limited to 1 level |
| 493 | */ |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 494 | if (argv[1][0] == 'l') { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 495 | 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 Gala | 51ab7f9 | 2007-10-25 16:15:07 -0500 | [diff] [blame] | 502 | if (argc == 2) |
| 503 | pathp = root; |
| 504 | else |
| 505 | pathp = argv[2]; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 506 | if (argc > 3) |
| 507 | prop = argv[3]; |
| 508 | else |
| 509 | prop = NULL; |
| 510 | |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 511 | ret = fdt_print(pathp, prop, depth); |
| 512 | if (ret != 0) |
| 513 | return ret; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 514 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 515 | /* |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 516 | * Remove a property/node |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 517 | */ |
Gerald Van Baren | 3b9d629 | 2008-06-09 21:02:17 -0400 | [diff] [blame] | 518 | } else if (strncmp(argv[1], "rm", 2) == 0) { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 519 | 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 Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 526 | nodeoffset = fdt_path_offset (working_fdt, argv[2]); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 527 | if (nodeoffset < 0) { |
| 528 | /* |
| 529 | * Not found or something else bad happened. |
| 530 | */ |
Kumar Gala | c8ab705 | 2007-10-24 11:04:22 -0500 | [diff] [blame] | 531 | printf ("libfdt fdt_path_offset() returned %s\n", |
Gerald Van Baren | 1178d6a | 2007-05-21 23:27:16 -0400 | [diff] [blame] | 532 | fdt_strerror(nodeoffset)); |
Gerald Van Baren | 0ea55d2 | 2007-05-12 09:47:25 -0400 | [diff] [blame] | 533 | return 1; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 534 | } |
| 535 | /* |
| 536 | * Do the delete. A fourth parameter means delete a property, |
| 537 | * otherwise delete the node. |
| 538 | */ |
| 539 | if (argc > 3) { |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 540 | err = fdt_delprop(working_fdt, nodeoffset, argv[3]); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 541 | if (err < 0) { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 542 | printf("libfdt fdt_delprop(): %s\n", |
| 543 | fdt_strerror(err)); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 544 | return err; |
| 545 | } |
| 546 | } else { |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 547 | err = fdt_del_node(working_fdt, nodeoffset); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 548 | if (err < 0) { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 549 | printf("libfdt fdt_del_node(): %s\n", |
| 550 | fdt_strerror(err)); |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 551 | return err; |
| 552 | } |
| 553 | } |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 554 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 555 | /* |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 556 | * Display header info |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 557 | */ |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 558 | } else if (argv[1][0] == 'h') { |
Heiko Schocher | fefc7ee | 2018-11-15 06:06:06 +0100 | [diff] [blame] | 559 | if (argc == 5) |
| 560 | return fdt_get_header_value(argc, argv); |
| 561 | |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 562 | 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 Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 572 | printf("version:\t\t%d\n", version); |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 573 | printf("last_comp_version:\t%d\n", |
| 574 | fdt_last_comp_version(working_fdt)); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 575 | if (version >= 2) |
| 576 | printf("boot_cpuid_phys:\t0x%x\n", |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 577 | fdt_boot_cpuid_phys(working_fdt)); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 578 | if (version >= 3) |
| 579 | printf("size_dt_strings:\t0x%x\n", |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 580 | fdt_size_dt_strings(working_fdt)); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 581 | if (version >= 17) |
| 582 | printf("size_dt_struct:\t\t0x%x\n", |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 583 | fdt_size_dt_struct(working_fdt)); |
| 584 | printf("number mem_rsv:\t\t0x%x\n", |
| 585 | fdt_num_mem_rsv(working_fdt)); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 586 | printf("\n"); |
| 587 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 588 | /* |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 589 | * Set boot cpu id |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 590 | */ |
Gerald Van Baren | 3b9d629 | 2008-06-09 21:02:17 -0400 | [diff] [blame] | 591 | } else if (strncmp(argv[1], "boo", 3) == 0) { |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 592 | unsigned long tmp = hextoul(argv[2], NULL); |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 593 | fdt_set_boot_cpuid_phys(working_fdt, tmp); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 594 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 595 | /* |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 596 | * memory command |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 597 | */ |
Gerald Van Baren | 3b9d629 | 2008-06-09 21:02:17 -0400 | [diff] [blame] | 598 | } else if (strncmp(argv[1], "me", 2) == 0) { |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 599 | uint64_t addr, size; |
| 600 | int err; |
Heiko Schocher | 0f602e1 | 2009-12-03 11:21:21 +0100 | [diff] [blame] | 601 | addr = simple_strtoull(argv[2], NULL, 16); |
| 602 | size = simple_strtoull(argv[3], NULL, 16); |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 603 | err = fdt_fixup_memory(working_fdt, addr, size); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 604 | if (err < 0) |
| 605 | return err; |
| 606 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 607 | /* |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 608 | * mem reserve commands |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 609 | */ |
Gerald Van Baren | 3b9d629 | 2008-06-09 21:02:17 -0400 | [diff] [blame] | 610 | } else if (strncmp(argv[1], "rs", 2) == 0) { |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 611 | if (argv[2][0] == 'p') { |
| 612 | uint64_t addr, size; |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 613 | int total = fdt_num_mem_rsv(working_fdt); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 614 | 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 Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 619 | err = fdt_get_mem_rsv(working_fdt, j, &addr, &size); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 620 | 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 Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 634 | addr = simple_strtoull(argv[3], NULL, 16); |
| 635 | size = simple_strtoull(argv[4], NULL, 16); |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 636 | err = fdt_add_mem_rsv(working_fdt, addr, size); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 637 | |
| 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 Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 644 | unsigned long idx = hextoul(argv[3], NULL); |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 645 | int err = fdt_del_mem_rsv(working_fdt, idx); |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 646 | |
| 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 Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 654 | return CMD_RET_USAGE; |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 655 | } |
Kim Phillips | bd9d115 | 2007-07-17 13:57:04 -0500 | [diff] [blame] | 656 | } |
Gerald Van Baren | 5606a36 | 2007-06-25 23:25:28 -0400 | [diff] [blame] | 657 | #ifdef CONFIG_OF_BOARD_SETUP |
Kim Phillips | bd9d115 | 2007-07-17 13:57:04 -0500 | [diff] [blame] | 658 | /* Call the board-specific fixup routine */ |
Simon Glass | 406ba62 | 2014-10-23 18:58:48 -0600 | [diff] [blame] | 659 | 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 Rini | 84c0f69 | 2021-09-12 20:32:32 -0400 | [diff] [blame] | 667 | #ifdef CONFIG_ARCH_KEYSTONE |
Nicholas Faustini | e5fb786 | 2018-10-03 12:58:48 +0200 | [diff] [blame] | 668 | ft_board_setup_ex(working_fdt, gd->bd); |
| 669 | #endif |
Simon Glass | 406ba62 | 2014-10-23 18:58:48 -0600 | [diff] [blame] | 670 | } |
Gerald Van Baren | 5606a36 | 2007-06-25 23:25:28 -0400 | [diff] [blame] | 671 | #endif |
Kim Phillips | bd9d115 | 2007-07-17 13:57:04 -0500 | [diff] [blame] | 672 | /* Create a chosen node */ |
Heiko Schocher | fce16b9 | 2014-03-03 12:19:24 +0100 | [diff] [blame] | 673 | else if (strncmp(argv[1], "cho", 3) == 0) { |
Kumar Gala | fb5dcd5 | 2008-08-15 08:24:34 -0500 | [diff] [blame] | 674 | unsigned long initrd_start = 0, initrd_end = 0; |
| 675 | |
Wolfgang Denk | 3b68311 | 2010-07-17 01:06:04 +0200 | [diff] [blame] | 676 | if ((argc != 2) && (argc != 4)) |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 677 | return CMD_RET_USAGE; |
Kumar Gala | fb5dcd5 | 2008-08-15 08:24:34 -0500 | [diff] [blame] | 678 | |
| 679 | if (argc == 4) { |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 680 | initrd_start = hextoul(argv[2], NULL); |
Sean Anderson | 86b6f47 | 2022-03-22 16:59:21 -0400 | [diff] [blame] | 681 | initrd_end = initrd_start + hextoul(argv[3], NULL) - 1; |
Kumar Gala | fb5dcd5 | 2008-08-15 08:24:34 -0500 | [diff] [blame] | 682 | } |
| 683 | |
Masahiro Yamada | 451c204 | 2014-04-18 17:41:00 +0900 | [diff] [blame] | 684 | fdt_chosen(working_fdt); |
Masahiro Yamada | 5b11489 | 2014-04-18 17:40:59 +0900 | [diff] [blame] | 685 | fdt_initrd(working_fdt, initrd_start, initrd_end); |
Heiko Schocher | fce16b9 | 2014-03-03 12:19:24 +0100 | [diff] [blame] | 686 | |
| 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 Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 698 | addr = hextoul(argv[2], NULL); |
Heiko Schocher | fce16b9 | 2014-03-03 12:19:24 +0100 | [diff] [blame] | 699 | 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 Glass | 5da42d9 | 2014-06-12 07:24:45 -0600 | [diff] [blame] | 715 | if (ret == 0) |
Heiko Schocher | fce16b9 | 2014-03-03 12:19:24 +0100 | [diff] [blame] | 716 | return CMD_RET_SUCCESS; |
| 717 | else |
| 718 | return CMD_RET_FAILURE; |
| 719 | #endif |
| 720 | |
Kumar Gala | 58911df | 2008-08-15 08:24:44 -0500 | [diff] [blame] | 721 | } |
Maxime Ripard | 5a680aa | 2016-07-05 10:26:45 +0200 | [diff] [blame] | 722 | #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 Agner | fed14d0 | 2016-12-20 15:58:45 +0100 | [diff] [blame] | 727 | int ret; |
Maxime Ripard | 5a680aa | 2016-07-05 10:26:45 +0200 | [diff] [blame] | 728 | |
| 729 | if (argc != 3) |
| 730 | return CMD_RET_USAGE; |
| 731 | |
| 732 | if (!working_fdt) |
| 733 | return CMD_RET_FAILURE; |
| 734 | |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 735 | addr = hextoul(argv[2], NULL); |
Maxime Ripard | 5a680aa | 2016-07-05 10:26:45 +0200 | [diff] [blame] | 736 | blob = map_sysmem(addr, 0); |
| 737 | if (!fdt_valid(&blob)) |
| 738 | return CMD_RET_FAILURE; |
| 739 | |
Pantelis Antoniou | d9456a4 | 2017-09-04 23:12:12 +0300 | [diff] [blame] | 740 | /* apply method prints messages on error */ |
| 741 | ret = fdt_overlay_apply_verbose(working_fdt, blob); |
| 742 | if (ret) |
Maxime Ripard | 5a680aa | 2016-07-05 10:26:45 +0200 | [diff] [blame] | 743 | return CMD_RET_FAILURE; |
| 744 | } |
| 745 | #endif |
Kumar Gala | 58911df | 2008-08-15 08:24:44 -0500 | [diff] [blame] | 746 | /* resize the fdt */ |
| 747 | else if (strncmp(argv[1], "re", 2) == 0) { |
Hannes Schmelzer | d3dbac8 | 2016-09-20 18:10:43 +0200 | [diff] [blame] | 748 | uint extrasize; |
| 749 | if (argc > 2) |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 750 | extrasize = hextoul(argv[2], NULL); |
Hannes Schmelzer | d3dbac8 | 2016-09-20 18:10:43 +0200 | [diff] [blame] | 751 | else |
| 752 | extrasize = 0; |
| 753 | fdt_shrink_to_minimum(working_fdt, extrasize); |
Kumar Gala | 58911df | 2008-08-15 08:24:44 -0500 | [diff] [blame] | 754 | } |
| 755 | else { |
Kim Phillips | bd9d115 | 2007-07-17 13:57:04 -0500 | [diff] [blame] | 756 | /* Unrecognized command */ |
Simon Glass | a06dfc7 | 2011-12-10 08:44:01 +0000 | [diff] [blame] | 757 | return CMD_RET_USAGE; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 758 | } |
| 759 | |
| 760 | return 0; |
| 761 | } |
| 762 | |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 763 | /****************************************************************************/ |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 764 | |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 765 | /* |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 766 | * Parse the user's input, partially heuristic. Valid formats: |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 767 | * <0x00112233 4 05> - an array of cells. Numbers follow standard |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 768 | * C conventions. |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 769 | * [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 Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 773 | * newval: An array of strings containing the new property as specified |
Wolfgang Denk | a1be476 | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 774 | * on the command line |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 775 | * 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 Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 778 | */ |
Wolfgang Denk | 6262d021 | 2010-06-28 22:00:46 +0200 | [diff] [blame] | 779 | 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] | 780 | { |
| 781 | char *cp; /* temporary char pointer */ |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 782 | char *newp; /* temporary newval char pointer */ |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 783 | unsigned long tmp; /* holds converted values */ |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 784 | int stridx = 0; |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 785 | |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 786 | *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 Schmelzer | 9878861 | 2017-05-30 15:05:44 +0200 | [diff] [blame] | 804 | if (*cp != '?') |
| 805 | *(fdt32_t *)data = cpu_to_fdt32(tmp); |
| 806 | else |
| 807 | newp++; |
| 808 | |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 809 | data += 4; |
| 810 | *len += 4; |
| 811 | |
| 812 | /* If the ptr didn't advance, something went wrong */ |
| 813 | if ((newp - cp) <= 0) { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 814 | printf("Sorry, I could not convert \"%s\"\n", |
| 815 | cp); |
| 816 | return 1; |
| 817 | } |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 818 | |
| 819 | while (*newp == ' ') |
| 820 | newp++; |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 821 | } |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 822 | |
| 823 | if (*newp != '>') { |
| 824 | printf("Unexpected character '%c'\n", *newp); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 825 | return 1; |
| 826 | } |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 827 | } else if (*newp == '[') { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 828 | /* |
| 829 | * Byte stream. Convert the values. |
| 830 | */ |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 831 | newp++; |
Ken MacLeod | d028afa | 2009-09-11 15:16:18 -0500 | [diff] [blame] | 832 | while ((stridx < count) && (*newp != ']')) { |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 833 | while (*newp == ' ') |
| 834 | newp++; |
Ken MacLeod | d028afa | 2009-09-11 15:16:18 -0500 | [diff] [blame] | 835 | if (*newp == '\0') { |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 836 | newp = newval[++stridx]; |
Ken MacLeod | d028afa | 2009-09-11 15:16:18 -0500 | [diff] [blame] | 837 | continue; |
| 838 | } |
| 839 | if (!isxdigit(*newp)) |
| 840 | break; |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 841 | tmp = hextoul(newp, &newp); |
Ken MacLeod | d028afa | 2009-09-11 15:16:18 -0500 | [diff] [blame] | 842 | *data++ = tmp & 0xFF; |
| 843 | *len = *len + 1; |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 844 | } |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 845 | if (*newp != ']') { |
Andrew Klossner | e4ad454 | 2008-07-07 06:41:14 -0700 | [diff] [blame] | 846 | printf("Unexpected character '%c'\n", *newp); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 847 | return 1; |
| 848 | } |
| 849 | } else { |
| 850 | /* |
Ken MacLeod | d028afa | 2009-09-11 15:16:18 -0500 | [diff] [blame] | 851 | * Assume it is one or more strings. Copy it into our |
| 852 | * data area for convenience (including the |
| 853 | * terminating '\0's). |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 854 | */ |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 855 | while (stridx < count) { |
Ken MacLeod | d028afa | 2009-09-11 15:16:18 -0500 | [diff] [blame] | 856 | size_t length = strlen(newp) + 1; |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 857 | strcpy(data, newp); |
Ken MacLeod | d028afa | 2009-09-11 15:16:18 -0500 | [diff] [blame] | 858 | data += length; |
| 859 | *len += length; |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 860 | newp = newval[++stridx]; |
| 861 | } |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 862 | } |
| 863 | return 0; |
| 864 | } |
| 865 | |
| 866 | /****************************************************************************/ |
| 867 | |
| 868 | /* |
| 869 | * Heuristic to guess if this is a string or concatenated strings. |
| 870 | */ |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 871 | |
| 872 | static 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 Hershberger | ea2243b | 2012-08-17 10:34:38 +0000 | [diff] [blame] | 880 | /* must terminate with zero or '\n' */ |
| 881 | if (s[len - 1] != '\0' && s[len - 1] != '\n') |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 882 | return 0; |
| 883 | |
| 884 | /* printable or a null byte (concatenated strings) */ |
Joe Hershberger | ea2243b | 2012-08-17 10:34:38 +0000 | [diff] [blame] | 885 | while (((*s == '\0') || isprint(*s) || isspace(*s)) && (len > 0)) { |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 886 | /* |
| 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 Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 909 | |
| 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 Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 915 | static void print_data(const void *data, int len) |
| 916 | { |
| 917 | int j; |
Heinrich Schuchardt | 1a5f58d | 2020-06-19 19:45:55 +0200 | [diff] [blame] | 918 | const char *env_max_dump; |
| 919 | ulong max_dump = ULONG_MAX; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 920 | |
| 921 | /* no data, don't print */ |
| 922 | if (len == 0) |
| 923 | return; |
| 924 | |
Heinrich Schuchardt | 1a5f58d | 2020-06-19 19:45:55 +0200 | [diff] [blame] | 925 | env_max_dump = env_get("fdt_max_dump"); |
| 926 | if (env_max_dump) |
Simon Glass | 3ff49ec | 2021-07-24 09:03:29 -0600 | [diff] [blame] | 927 | max_dump = hextoul(env_max_dump, NULL); |
Heinrich Schuchardt | 1a5f58d | 2020-06-19 19:45:55 +0200 | [diff] [blame] | 928 | |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 929 | /* |
| 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 Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 946 | if ((len %4) == 0) { |
Heinrich Schuchardt | 1a5f58d | 2020-06-19 19:45:55 +0200 | [diff] [blame] | 947 | if (len > max_dump) |
Tom Rini | 1db8b53 | 2012-10-29 14:53:18 +0000 | [diff] [blame] | 948 | printf("* 0x%p [0x%08x]", data, len); |
Joe Hershberger | f72c692 | 2012-08-17 10:34:36 +0000 | [diff] [blame] | 949 | else { |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 950 | const __be32 *p; |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 951 | |
Joe Hershberger | f72c692 | 2012-08-17 10:34:36 +0000 | [diff] [blame] | 952 | 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 Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 958 | } else { /* anything else... hexdump */ |
Heinrich Schuchardt | 1a5f58d | 2020-06-19 19:45:55 +0200 | [diff] [blame] | 959 | if (len > max_dump) |
Tom Rini | 1db8b53 | 2012-10-29 14:53:18 +0000 | [diff] [blame] | 960 | printf("* 0x%p [0x%08x]", data, len); |
Joe Hershberger | f72c692 | 2012-08-17 10:34:36 +0000 | [diff] [blame] | 961 | else { |
| 962 | const u8 *s; |
Andy Fleming | 4689147 | 2008-03-31 20:45:56 -0500 | [diff] [blame] | 963 | |
Joe Hershberger | f72c692 | 2012-08-17 10:34:36 +0000 | [diff] [blame] | 964 | printf("["); |
| 965 | for (j = 0, s = data; j < len; j++) |
| 966 | printf("%02x%s", s[j], j < len - 1 ? " " : ""); |
| 967 | printf("]"); |
| 968 | } |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 969 | } |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 970 | } |
| 971 | |
| 972 | /****************************************************************************/ |
| 973 | |
| 974 | /* |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 975 | * Recursively print (a portion of) the working_fdt. The depth parameter |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 976 | * determines how deeply nested the fdt is printed. |
| 977 | */ |
Kumar Gala | 1e386af | 2007-11-21 14:07:46 -0600 | [diff] [blame] | 978 | static int fdt_print(const char *pathp, char *prop, int depth) |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 979 | { |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 980 | 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 Gala | 1e386af | 2007-11-21 14:07:46 -0600 | [diff] [blame] | 983 | const void *nodep; /* property node pointer */ |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 984 | 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 Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 989 | const struct fdt_property *fdt_prop; |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 990 | |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 991 | nodeoffset = fdt_path_offset (working_fdt, pathp); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 992 | if (nodeoffset < 0) { |
| 993 | /* |
| 994 | * Not found or something else bad happened. |
| 995 | */ |
Kumar Gala | c8ab705 | 2007-10-24 11:04:22 -0500 | [diff] [blame] | 996 | printf ("libfdt fdt_path_offset() returned %s\n", |
Gerald Van Baren | 1178d6a | 2007-05-21 23:27:16 -0400 | [diff] [blame] | 997 | fdt_strerror(nodeoffset)); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 998 | 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 Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 1005 | nodep = fdt_getprop (working_fdt, nodeoffset, prop, &len); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1006 | if (len == 0) { |
| 1007 | /* no property value */ |
| 1008 | printf("%s %s\n", pathp, prop); |
| 1009 | return 0; |
Simon Glass | 4bc73ef | 2017-06-07 10:28:42 -0600 | [diff] [blame] | 1010 | } else if (nodep && len > 0) { |
Gerald Van Baren | fc1a109 | 2007-11-23 19:43:20 -0500 | [diff] [blame] | 1011 | printf("%s = ", prop); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1012 | 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 Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1026 | while(level >= 0) { |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 1027 | tag = fdt_next_tag(working_fdt, nodeoffset, &nextoffset); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1028 | switch(tag) { |
| 1029 | case FDT_BEGIN_NODE: |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 1030 | pathp = fdt_get_name(working_fdt, nodeoffset, NULL); |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1031 | if (level <= depth) { |
| 1032 | if (pathp == NULL) |
| 1033 | pathp = "/* NULL pointer error */"; |
| 1034 | if (*pathp == '\0') |
| 1035 | pathp = "/"; /* root is nameless */ |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1036 | printf("%s%s {\n", |
| 1037 | &tabs[MAX_LEVEL - level], pathp); |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1038 | } |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1039 | level++; |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1040 | if (level >= MAX_LEVEL) { |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1041 | printf("Nested too deep, aborting.\n"); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1042 | return 1; |
| 1043 | } |
| 1044 | break; |
| 1045 | case FDT_END_NODE: |
| 1046 | level--; |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1047 | if (level <= depth) |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1048 | 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 Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 1054 | fdt_prop = fdt_offset_ptr(working_fdt, nodeoffset, |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1055 | sizeof(*fdt_prop)); |
Kim Phillips | f3a42e2 | 2008-06-10 11:06:17 -0500 | [diff] [blame] | 1056 | pathp = fdt_string(working_fdt, |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1057 | fdt32_to_cpu(fdt_prop->nameoff)); |
| 1058 | len = fdt32_to_cpu(fdt_prop->len); |
| 1059 | nodep = fdt_prop->data; |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1060 | 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 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%s;\n", |
| 1068 | &tabs[MAX_LEVEL - level], |
| 1069 | pathp); |
| 1070 | } else { |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1071 | if (level <= depth) { |
Gerald Van Baren | fc1a109 | 2007-11-23 19:43:20 -0500 | [diff] [blame] | 1072 | printf("%s%s = ", |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1073 | &tabs[MAX_LEVEL - level], |
| 1074 | pathp); |
| 1075 | print_data (nodep, len); |
| 1076 | printf(";\n"); |
| 1077 | } |
| 1078 | } |
| 1079 | break; |
| 1080 | case FDT_NOP: |
Andrew Klossner | e4ad454 | 2008-07-07 06:41:14 -0700 | [diff] [blame] | 1081 | printf("%s/* NOP */\n", &tabs[MAX_LEVEL - level]); |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1082 | break; |
| 1083 | case FDT_END: |
| 1084 | return 1; |
| 1085 | default: |
Gerald Van Baren | eb999ee | 2007-11-22 17:23:23 -0500 | [diff] [blame] | 1086 | if (level <= depth) |
Gerald Van Baren | e596a16 | 2007-05-16 22:39:59 -0400 | [diff] [blame] | 1087 | printf("Unknown tag 0x%08X\n", tag); |
| 1088 | return 1; |
| 1089 | } |
| 1090 | nodeoffset = nextoffset; |
| 1091 | } |
| 1092 | return 0; |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 1093 | } |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 1094 | |
| 1095 | /********************************************************************/ |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 1096 | #ifdef CONFIG_SYS_LONGHELP |
| 1097 | static char fdt_help_text[] = |
Heinrich Schuchardt | 9696dbb | 2022-04-25 18:35:05 +0200 | [diff] [blame] | 1098 | "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] | 1099 | #ifdef CONFIG_OF_LIBFDT_OVERLAY |
| 1100 | "fdt apply <addr> - Apply overlay to the DT\n" |
| 1101 | #endif |
Gerald Van Baren | 5606a36 | 2007-06-25 23:25:28 -0400 | [diff] [blame] | 1102 | #ifdef CONFIG_OF_BOARD_SETUP |
| 1103 | "fdt boardsetup - Do board-specific set up\n" |
| 1104 | #endif |
Simon Glass | 6c0be91 | 2014-10-23 18:58:54 -0600 | [diff] [blame] | 1105 | #ifdef CONFIG_OF_SYSTEM_SETUP |
| 1106 | "fdt systemsetup - Do system-specific set up\n" |
| 1107 | #endif |
Gerald Van Baren | 7655c09 | 2008-01-05 15:33:29 -0500 | [diff] [blame] | 1108 | "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] | 1109 | "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] | 1110 | "fdt print <path> [<prop>] - Recursive print starting at <path>\n" |
| 1111 | "fdt list <path> [<prop>] - Print one level starting at <path>\n" |
Marek Vasut | 0282f9f | 2022-07-08 23:50:43 +0200 | [diff] [blame] | 1112 | "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 Hershberger | fc5abf0 | 2012-08-17 10:34:37 +0000 | [diff] [blame] | 1115 | "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 Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 1118 | "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 Schocher | fefc7ee | 2018-11-15 06:06:06 +0100 | [diff] [blame] | 1121 | "fdt header [get <var> <member>] - Display header info\n" |
| 1122 | " get - get header member <member> and store it in <var>\n" |
Kumar Gala | b79da7b | 2008-02-15 03:34:36 -0600 | [diff] [blame] | 1123 | "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 Anderson | 86b6f47 | 2022-03-22 16:59:21 -0400 | [diff] [blame] | 1128 | "fdt chosen [<start> <size>] - Add/update the /chosen branch in the tree\n" |
| 1129 | " <start>/<size> - initrd start addr/size\n" |
Heiko Schocher | fce16b9 | 2014-03-03 12:19:24 +0100 | [diff] [blame] | 1130 | #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. Day | 8c60f92 | 2016-05-04 04:47:31 -0400 | [diff] [blame] | 1135 | "NOTE: Dereference aliases by omitting the leading '/', " |
Kim Phillips | dc00a68 | 2012-10-29 13:34:31 +0000 | [diff] [blame] | 1136 | "e.g. fdt print ethernet0."; |
| 1137 | #endif |
| 1138 | |
| 1139 | U_BOOT_CMD( |
| 1140 | fdt, 255, 0, do_fdt, |
| 1141 | "flattened device tree utility commands", fdt_help_text |
Gerald Van Baren | ade8ef4 | 2007-03-31 12:22:10 -0400 | [diff] [blame] | 1142 | ); |