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
27static 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
47static 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. */
153static const char usage_synopsis[] = "fdtdump [options] <file>";
154static const char usage_short_opts[] = "ds" USAGE_COMMON_SHORT_OPTS;
155static struct option const usage_long_opts[] = {
156	{"debug",            no_argument, NULL, 'd'},
157	{"scan",             no_argument, NULL, 's'},
158	USAGE_COMMON_LONG_OPTS
159};
160static 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
166static 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
180int 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