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