1 /* $NetBSD: fdtdump.c,v 1.4 2019/12/22 12:38:24 skrll Exp $ */ 2 3 // SPDX-License-Identifier: GPL-2.0-or-later 4 /* 5 * fdtdump.c - Contributed by Pantelis Antoniou <pantelis.antoniou AT gmail.com> 6 */ 7 8 #include <stdbool.h> 9 #include <stdint.h> 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <string.h> 13 #include <ctype.h> 14 #include <inttypes.h> 15 16 #include <libfdt.h> 17 #include <libfdt_env.h> 18 #include <fdt.h> 19 20 #include "util.h" 21 22 #define FDT_MAGIC_SIZE 4 23 #define MAX_VERSION 17 24 25 #define GET_CELL(p) (p += 4, *((const fdt32_t *)(p-4))) 26 27 static const char *tagname(uint32_t tag) 28 { 29 static const char * const names[] = { 30 #define TN(t) [t] = #t 31 TN(FDT_BEGIN_NODE), 32 TN(FDT_END_NODE), 33 TN(FDT_PROP), 34 TN(FDT_NOP), 35 TN(FDT_END), 36 #undef TN 37 }; 38 if (tag < ARRAY_SIZE(names)) 39 if (names[tag]) 40 return names[tag]; 41 return "FDT_???"; 42 } 43 44 #define dumpf(fmt, args...) \ 45 do { if (debug) printf("// " fmt, ## args); } while (0) 46 47 static void dump_blob(void *blob, bool debug) 48 { 49 uintptr_t blob_off = (uintptr_t)blob; 50 struct fdt_header *bph = blob; 51 uint32_t off_mem_rsvmap = fdt32_to_cpu(bph->off_mem_rsvmap); 52 uint32_t off_dt = fdt32_to_cpu(bph->off_dt_struct); 53 uint32_t off_str = fdt32_to_cpu(bph->off_dt_strings); 54 struct fdt_reserve_entry *p_rsvmap = 55 (struct fdt_reserve_entry *)((char *)blob + off_mem_rsvmap); 56 const char *p_struct = (const char *)blob + off_dt; 57 const char *p_strings = (const char *)blob + off_str; 58 uint32_t version = fdt32_to_cpu(bph->version); 59 uint32_t totalsize = fdt32_to_cpu(bph->totalsize); 60 uint32_t tag; 61 const char *p, *s, *t; 62 int depth, sz, shift; 63 int i; 64 uint64_t addr, size; 65 66 depth = 0; 67 shift = 4; 68 69 printf("/dts-v1/;\n"); 70 printf("// magic:\t\t0x%"PRIx32"\n", fdt32_to_cpu(bph->magic)); 71 printf("// totalsize:\t\t0x%"PRIx32" (%"PRIu32")\n", 72 totalsize, totalsize); 73 printf("// off_dt_struct:\t0x%"PRIx32"\n", off_dt); 74 printf("// off_dt_strings:\t0x%"PRIx32"\n", off_str); 75 printf("// off_mem_rsvmap:\t0x%"PRIx32"\n", off_mem_rsvmap); 76 printf("// version:\t\t%"PRIu32"\n", version); 77 printf("// last_comp_version:\t%"PRIu32"\n", 78 fdt32_to_cpu(bph->last_comp_version)); 79 if (version >= 2) 80 printf("// boot_cpuid_phys:\t0x%"PRIx32"\n", 81 fdt32_to_cpu(bph->boot_cpuid_phys)); 82 83 if (version >= 3) 84 printf("// size_dt_strings:\t0x%"PRIx32"\n", 85 fdt32_to_cpu(bph->size_dt_strings)); 86 if (version >= 17) 87 printf("// size_dt_struct:\t0x%"PRIx32"\n", 88 fdt32_to_cpu(bph->size_dt_struct)); 89 printf("\n"); 90 91 for (i = 0; ; i++) { 92 addr = fdt64_to_cpu(p_rsvmap[i].address); 93 size = fdt64_to_cpu(p_rsvmap[i].size); 94 if (addr == 0 && size == 0) 95 break; 96 97 printf("/memreserve/ %#"PRIx64" %#"PRIx64";\n", 98 addr, size); 99 } 100 101 p = p_struct; 102 while ((tag = fdt32_to_cpu(GET_CELL(p))) != FDT_END) { 103 104 dumpf("%04"PRIxPTR": tag: 0x%08"PRIx32" (%s)\n", 105 (uintptr_t)p - blob_off - 4, tag, tagname(tag)); 106 107 if (tag == FDT_BEGIN_NODE) { 108 s = p; 109 p = PALIGN(p + strlen(s) + 1, 4); 110 111 if (*s == '\0') 112 s = "/"; 113 114 printf("%*s%s {\n", depth * shift, "", s); 115 116 depth++; 117 continue; 118 } 119 120 if (tag == FDT_END_NODE) { 121 depth--; 122 123 printf("%*s};\n", depth * shift, ""); 124 continue; 125 } 126 127 if (tag == FDT_NOP) { 128 printf("%*s// [NOP]\n", depth * shift, ""); 129 continue; 130 } 131 132 if (tag != FDT_PROP) { 133 fprintf(stderr, "%*s ** Unknown tag 0x%08"PRIx32"\n", depth * shift, "", tag); 134 break; 135 } 136 sz = fdt32_to_cpu(GET_CELL(p)); 137 s = p_strings + fdt32_to_cpu(GET_CELL(p)); 138 if (version < 16 && sz >= 8) 139 p = PALIGN(p, 8); 140 t = p; 141 142 p = PALIGN(p + sz, 4); 143 144 dumpf("%04"PRIxPTR": string: %s\n", (uintptr_t)s - blob_off, s); 145 dumpf("%04"PRIxPTR": value\n", (uintptr_t)t - blob_off); 146 printf("%*s%s", depth * shift, "", s); 147 utilfdt_print_data(t, sz); 148 printf(";\n"); 149 } 150 } 151 152 /* Usage related data. */ 153 static const char usage_synopsis[] = "fdtdump [options] <file>"; 154 static const char usage_short_opts[] = "ds" USAGE_COMMON_SHORT_OPTS; 155 static struct option const usage_long_opts[] = { 156 {"debug", no_argument, NULL, 'd'}, 157 {"scan", no_argument, NULL, 's'}, 158 USAGE_COMMON_LONG_OPTS 159 }; 160 static const char * const usage_opts_help[] = { 161 "Dump debug information while decoding the file", 162 "Scan for an embedded fdt in file", 163 USAGE_COMMON_OPTS_HELP 164 }; 165 166 static bool valid_header(char *p, off_t len) 167 { 168 if (len < sizeof(struct fdt_header) || 169 fdt_magic(p) != FDT_MAGIC || 170 fdt_version(p) > MAX_VERSION || 171 fdt_last_comp_version(p) > MAX_VERSION || 172 fdt_totalsize(p) >= len || 173 fdt_off_dt_struct(p) >= len || 174 fdt_off_dt_strings(p) >= len) 175 return 0; 176 else 177 return 1; 178 } 179 180 int main(int argc, char *argv[]) 181 { 182 int opt; 183 const char *file; 184 char *buf; 185 bool debug = false; 186 bool scan = false; 187 size_t len; 188 189 fprintf(stderr, "\n" 190 "**** fdtdump is a low-level debugging tool, not meant for general use.\n" 191 "**** If you want to decompile a dtb, you probably want\n" 192 "**** dtc -I dtb -O dts <filename>\n\n" 193 ); 194 while ((opt = util_getopt_long()) != EOF) { 195 switch (opt) { 196 case_USAGE_COMMON_FLAGS 197 198 case 'd': 199 debug = true; 200 break; 201 case 's': 202 scan = true; 203 break; 204 } 205 } 206 if (optind != argc - 1) 207 usage("missing input filename"); 208 file = argv[optind]; 209 210 buf = utilfdt_read(file, &len); 211 if (!buf) 212 die("could not read: %s\n", file); 213 214 /* try and locate an embedded fdt in a bigger blob */ 215 if (scan) { 216 unsigned char smagic[FDT_MAGIC_SIZE]; 217 char *p = buf; 218 char *endp = buf + len; 219 220 fdt_set_magic(smagic, FDT_MAGIC); 221 222 /* poor man's memmem */ 223 while ((endp - p) >= FDT_MAGIC_SIZE) { 224 p = memchr(p, smagic[0], endp - p - FDT_MAGIC_SIZE); 225 if (!p) 226 break; 227 if (fdt_magic(p) == FDT_MAGIC) { 228 /* try and validate the main struct */ 229 off_t this_len = endp - p; 230 if (valid_header(p, this_len)) 231 break; 232 if (debug) 233 printf("%s: skipping fdt magic at offset %#tx\n", 234 file, p - buf); 235 } 236 ++p; 237 } 238 if (!p || endp - p < sizeof(struct fdt_header)) 239 die("%s: could not locate fdt magic\n", file); 240 printf("%s: found fdt at offset %#tx\n", file, p - buf); 241 buf = p; 242 } else if (!valid_header(buf, len)) 243 die("%s: header is not valid\n", file); 244 245 dump_blob(buf, debug); 246 247 return 0; 248 } 249
Indexes created Mon May 25 00:24:39 UTC 2026