blob: 25f7af61061e7543a765bcd75d120ff4d9fa23a1 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass8b50d522017-05-18 20:08:55 -06002/*
3 * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
4 * benh@kernel.crashing.org
5 *
6 * Based on parts of drivers/of/fdt.c from Linux v4.9
7 * Modifications for U-Boot
8 * Copyright (c) 2017 Google, Inc
Simon Glass8b50d522017-05-18 20:08:55 -06009 */
10
11#include <common.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060012#include <log.h>
Masahiro Yamadab08c8c42018-03-05 01:20:11 +090013#include <linux/libfdt.h>
Simon Glass8b50d522017-05-18 20:08:55 -060014#include <of_live.h>
15#include <malloc.h>
16#include <dm/of_access.h>
17#include <linux/err.h>
18
Simon Glass8b50d522017-05-18 20:08:55 -060019static void *unflatten_dt_alloc(void **mem, unsigned long size,
20 unsigned long align)
21{
22 void *res;
23
24 *mem = PTR_ALIGN(*mem, align);
25 res = *mem;
26 *mem += size;
27
28 return res;
29}
30
31/**
32 * unflatten_dt_node() - Alloc and populate a device_node from the flat tree
33 * @blob: The parent device tree blob
34 * @mem: Memory chunk to use for allocating device nodes and properties
35 * @poffset: pointer to node in flat tree
36 * @dad: Parent struct device_node
37 * @nodepp: The device_node tree created by the call
38 * @fpsize: Size of the node path up at t05he current depth.
39 * @dryrun: If true, do not allocate device nodes but still calculate needed
40 * memory size
41 */
42static void *unflatten_dt_node(const void *blob, void *mem, int *poffset,
43 struct device_node *dad,
44 struct device_node **nodepp,
45 unsigned long fpsize, bool dryrun)
46{
47 const __be32 *p;
48 struct device_node *np;
49 struct property *pp, **prev_pp = NULL;
50 const char *pathp;
51 int l;
52 unsigned int allocl;
53 static int depth;
54 int old_depth;
55 int offset;
56 int has_name = 0;
57 int new_format = 0;
58
59 pathp = fdt_get_name(blob, *poffset, &l);
60 if (!pathp)
61 return mem;
62
63 allocl = ++l;
64
65 /*
66 * version 0x10 has a more compact unit name here instead of the full
67 * path. we accumulate the full path size using "fpsize", we'll rebuild
68 * it later. We detect this because the first character of the name is
69 * not '/'.
70 */
71 if ((*pathp) != '/') {
72 new_format = 1;
73 if (fpsize == 0) {
74 /*
75 * root node: special case. fpsize accounts for path
76 * plus terminating zero. root node only has '/', so
77 * fpsize should be 2, but we want to avoid the first
78 * level nodes to have two '/' so we use fpsize 1 here
79 */
80 fpsize = 1;
81 allocl = 2;
82 l = 1;
83 pathp = "";
84 } else {
85 /*
86 * account for '/' and path size minus terminal 0
87 * already in 'l'
88 */
89 fpsize += l;
90 allocl = fpsize;
91 }
92 }
93
94 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
95 __alignof__(struct device_node));
96 if (!dryrun) {
97 char *fn;
98
99 fn = (char *)np + sizeof(*np);
Simon Glassf46ec932022-09-06 20:27:15 -0600100 if (new_format) {
101 np->name = pathp;
102 has_name = 1;
103 }
Simon Glass8b50d522017-05-18 20:08:55 -0600104 np->full_name = fn;
105 if (new_format) {
106 /* rebuild full path for new format */
107 if (dad && dad->parent) {
108 strcpy(fn, dad->full_name);
109#ifdef DEBUG
110 if ((strlen(fn) + l + 1) != allocl) {
111 debug("%s: p: %d, l: %d, a: %d\n",
112 pathp, (int)strlen(fn), l,
113 allocl);
114 }
115#endif
116 fn += strlen(fn);
117 }
118 *(fn++) = '/';
119 }
120 memcpy(fn, pathp, l);
121
122 prev_pp = &np->properties;
123 if (dad != NULL) {
124 np->parent = dad;
125 np->sibling = dad->child;
126 dad->child = np;
127 }
128 }
129 /* process properties */
130 for (offset = fdt_first_property_offset(blob, *poffset);
131 (offset >= 0);
132 (offset = fdt_next_property_offset(blob, offset))) {
133 const char *pname;
134 int sz;
135
136 p = fdt_getprop_by_offset(blob, offset, &pname, &sz);
137 if (!p) {
138 offset = -FDT_ERR_INTERNAL;
139 break;
140 }
141
142 if (pname == NULL) {
143 debug("Can't find property name in list !\n");
144 break;
145 }
146 if (strcmp(pname, "name") == 0)
147 has_name = 1;
148 pp = unflatten_dt_alloc(&mem, sizeof(struct property),
149 __alignof__(struct property));
150 if (!dryrun) {
151 /*
152 * We accept flattened tree phandles either in
153 * ePAPR-style "phandle" properties, or the
154 * legacy "linux,phandle" properties. If both
155 * appear and have different values, things
156 * will get weird. Don't do that. */
157 if ((strcmp(pname, "phandle") == 0) ||
158 (strcmp(pname, "linux,phandle") == 0)) {
159 if (np->phandle == 0)
160 np->phandle = be32_to_cpup(p);
161 }
162 /*
163 * And we process the "ibm,phandle" property
164 * used in pSeries dynamic device tree
165 * stuff */
166 if (strcmp(pname, "ibm,phandle") == 0)
167 np->phandle = be32_to_cpup(p);
168 pp->name = (char *)pname;
169 pp->length = sz;
170 pp->value = (__be32 *)p;
171 *prev_pp = pp;
172 prev_pp = &pp->next;
173 }
174 }
175 /*
176 * with version 0x10 we may not have the name property, recreate
177 * it here from the unit name if absent
178 */
179 if (!has_name) {
180 const char *p1 = pathp, *ps = pathp, *pa = NULL;
181 int sz;
182
183 while (*p1) {
184 if ((*p1) == '@')
185 pa = p1;
186 if ((*p1) == '/')
187 ps = p1 + 1;
188 p1++;
189 }
190 if (pa < ps)
191 pa = p1;
192 sz = (pa - ps) + 1;
193 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
194 __alignof__(struct property));
195 if (!dryrun) {
196 pp->name = "name";
197 pp->length = sz;
198 pp->value = pp + 1;
199 *prev_pp = pp;
200 prev_pp = &pp->next;
201 memcpy(pp->value, ps, sz - 1);
202 ((char *)pp->value)[sz - 1] = 0;
203 debug("fixed up name for %s -> %s\n", pathp,
204 (char *)pp->value);
205 }
206 }
207 if (!dryrun) {
208 *prev_pp = NULL;
Simon Glassf46ec932022-09-06 20:27:15 -0600209 if (!has_name)
210 np->name = of_get_property(np, "name", NULL);
Simon Glass8b50d522017-05-18 20:08:55 -0600211 np->type = of_get_property(np, "device_type", NULL);
212
213 if (!np->name)
214 np->name = "<NULL>";
215 if (!np->type)
216 np->type = "<NULL>"; }
217
218 old_depth = depth;
219 *poffset = fdt_next_node(blob, *poffset, &depth);
220 if (depth < 0)
221 depth = 0;
Simon Glassc1eb3d52017-06-12 06:21:34 -0600222 while (*poffset > 0 && depth > old_depth) {
Simon Glass8b50d522017-05-18 20:08:55 -0600223 mem = unflatten_dt_node(blob, mem, poffset, np, NULL,
224 fpsize, dryrun);
Simon Glassc1eb3d52017-06-12 06:21:34 -0600225 if (!mem)
226 return NULL;
227 }
Simon Glass8b50d522017-05-18 20:08:55 -0600228
229 if (*poffset < 0 && *poffset != -FDT_ERR_NOTFOUND) {
230 debug("unflatten: error %d processing FDT\n", *poffset);
231 return NULL;
232 }
233
234 /*
235 * Reverse the child list. Some drivers assumes node order matches .dts
236 * node order
237 */
238 if (!dryrun && np->child) {
239 struct device_node *child = np->child;
240 np->child = NULL;
241 while (child) {
242 struct device_node *next = child->sibling;
243
244 child->sibling = np->child;
245 np->child = child;
246 child = next;
247 }
248 }
249
250 if (nodepp)
251 *nodepp = np;
252
253 return mem;
254}
255
Simon Glass33104842022-07-30 15:52:08 -0600256int unflatten_device_tree(const void *blob, struct device_node **mynodes)
Simon Glass8b50d522017-05-18 20:08:55 -0600257{
258 unsigned long size;
259 int start;
260 void *mem;
261
262 debug(" -> unflatten_device_tree()\n");
263
264 if (!blob) {
265 debug("No device tree pointer\n");
266 return -EINVAL;
267 }
268
269 debug("Unflattening device tree:\n");
270 debug("magic: %08x\n", fdt_magic(blob));
271 debug("size: %08x\n", fdt_totalsize(blob));
272 debug("version: %08x\n", fdt_version(blob));
273
274 if (fdt_check_header(blob)) {
275 debug("Invalid device tree blob header\n");
276 return -EINVAL;
277 }
278
279 /* First pass, scan for size */
280 start = 0;
281 size = (unsigned long)unflatten_dt_node(blob, NULL, &start, NULL, NULL,
282 0, true);
Simon Glassc1eb3d52017-06-12 06:21:34 -0600283 if (!size)
284 return -EFAULT;
Simon Glass8b50d522017-05-18 20:08:55 -0600285 size = ALIGN(size, 4);
286
287 debug(" size is %lx, allocating...\n", size);
288
289 /* Allocate memory for the expanded device tree */
Simon Glass9cf39bb2023-06-01 10:22:40 -0600290 mem = memalign(__alignof__(struct device_node), size + 4);
Simon Glass8b50d522017-05-18 20:08:55 -0600291 memset(mem, '\0', size);
292
Simon Glass9cf39bb2023-06-01 10:22:40 -0600293 /* Set up value for dm_test_livetree_align() */
294 *(u32 *)mem = BAD_OF_ROOT;
295
Simon Glass8b50d522017-05-18 20:08:55 -0600296 *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
297
298 debug(" unflattening %p...\n", mem);
299
300 /* Second pass, do actual unflattening */
301 start = 0;
302 unflatten_dt_node(blob, mem, &start, NULL, mynodes, 0, false);
303 if (be32_to_cpup(mem + size) != 0xdeadbeef) {
304 debug("End of tree marker overwritten: %08x\n",
305 be32_to_cpup(mem + size));
306 return -ENOSPC;
307 }
308
309 debug(" <- unflatten_device_tree()\n");
310
311 return 0;
312}
313
314int of_live_build(const void *fdt_blob, struct device_node **rootp)
315{
316 int ret;
317
318 debug("%s: start\n", __func__);
319 ret = unflatten_device_tree(fdt_blob, rootp);
320 if (ret) {
321 debug("Failed to create live tree: err=%d\n", ret);
322 return ret;
323 }
324 ret = of_alias_scan();
325 if (ret) {
326 debug("Failed to scan live tree aliases: err=%d\n", ret);
327 return ret;
328 }
329 debug("%s: stop\n", __func__);
330
331 return ret;
332}
Simon Glassa8f2ac22023-06-01 10:22:42 -0600333
334void of_live_free(struct device_node *root)
335{
336 /* the tree is stored as a contiguous block of memory */
337 free(root);
338}