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