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