Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Functions for working with the Flattened Device Tree data format
4 : : *
5 : : * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
6 : : * benh@kernel.crashing.org
7 : : */
8 : :
9 : : #define pr_fmt(fmt) "OF: fdt: " fmt
10 : :
11 : : #include <linux/crc32.h>
12 : : #include <linux/kernel.h>
13 : : #include <linux/initrd.h>
14 : : #include <linux/memblock.h>
15 : : #include <linux/mutex.h>
16 : : #include <linux/of.h>
17 : : #include <linux/of_fdt.h>
18 : : #include <linux/of_reserved_mem.h>
19 : : #include <linux/sizes.h>
20 : : #include <linux/string.h>
21 : : #include <linux/errno.h>
22 : : #include <linux/slab.h>
23 : : #include <linux/libfdt.h>
24 : : #include <linux/debugfs.h>
25 : : #include <linux/serial_core.h>
26 : : #include <linux/sysfs.h>
27 : : #include <linux/random.h>
28 : :
29 : : #include <asm/setup.h> /* for COMMAND_LINE_SIZE */
30 : : #include <asm/page.h>
31 : :
32 : : #include "of_private.h"
33 : :
34 : : /*
35 : : * of_fdt_limit_memory - limit the number of regions in the /memory node
36 : : * @limit: maximum entries
37 : : *
38 : : * Adjust the flattened device tree to have at most 'limit' number of
39 : : * memory entries in the /memory node. This function may be called
40 : : * any time after initial_boot_param is set.
41 : : */
42 : 0 : void __init of_fdt_limit_memory(int limit)
43 : : {
44 : : int memory;
45 : : int len;
46 : : const void *val;
47 : : int nr_address_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
48 : : int nr_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
49 : : const __be32 *addr_prop;
50 : : const __be32 *size_prop;
51 : : int root_offset;
52 : : int cell_size;
53 : :
54 : 0 : root_offset = fdt_path_offset(initial_boot_params, "/");
55 : 0 : if (root_offset < 0)
56 : 0 : return;
57 : :
58 : 0 : addr_prop = fdt_getprop(initial_boot_params, root_offset,
59 : : "#address-cells", NULL);
60 : 0 : if (addr_prop)
61 : 0 : nr_address_cells = fdt32_to_cpu(*addr_prop);
62 : :
63 : 0 : size_prop = fdt_getprop(initial_boot_params, root_offset,
64 : : "#size-cells", NULL);
65 : 0 : if (size_prop)
66 : 0 : nr_size_cells = fdt32_to_cpu(*size_prop);
67 : :
68 : 0 : cell_size = sizeof(uint32_t)*(nr_address_cells + nr_size_cells);
69 : :
70 : 0 : memory = fdt_path_offset(initial_boot_params, "/memory");
71 : 0 : if (memory > 0) {
72 : 0 : val = fdt_getprop(initial_boot_params, memory, "reg", &len);
73 : 0 : if (len > limit*cell_size) {
74 : 0 : len = limit*cell_size;
75 : : pr_debug("Limiting number of entries to %d\n", limit);
76 : 0 : fdt_setprop(initial_boot_params, memory, "reg", val,
77 : : len);
78 : : }
79 : : }
80 : : }
81 : :
82 : 3 : static bool of_fdt_device_is_available(const void *blob, unsigned long node)
83 : : {
84 : 3 : const char *status = fdt_getprop(blob, node, "status", NULL);
85 : :
86 : 3 : if (!status)
87 : : return true;
88 : :
89 : 0 : if (!strcmp(status, "ok") || !strcmp(status, "okay"))
90 : : return true;
91 : :
92 : 0 : return false;
93 : : }
94 : :
95 : : static void *unflatten_dt_alloc(void **mem, unsigned long size,
96 : : unsigned long align)
97 : : {
98 : : void *res;
99 : :
100 : 3 : *mem = PTR_ALIGN(*mem, align);
101 : : res = *mem;
102 : 3 : *mem += size;
103 : :
104 : : return res;
105 : : }
106 : :
107 : 3 : static void populate_properties(const void *blob,
108 : : int offset,
109 : : void **mem,
110 : : struct device_node *np,
111 : : const char *nodename,
112 : : bool dryrun)
113 : : {
114 : : struct property *pp, **pprev = NULL;
115 : : int cur;
116 : : bool has_name = false;
117 : :
118 : 3 : pprev = &np->properties;
119 : 3 : for (cur = fdt_first_property_offset(blob, offset);
120 : : cur >= 0;
121 : 3 : cur = fdt_next_property_offset(blob, cur)) {
122 : : const __be32 *val;
123 : : const char *pname;
124 : : u32 sz;
125 : :
126 : 3 : val = fdt_getprop_by_offset(blob, cur, &pname, &sz);
127 : 3 : if (!val) {
128 : 0 : pr_warn("Cannot locate property at 0x%x\n", cur);
129 : 3 : continue;
130 : : }
131 : :
132 : 3 : if (!pname) {
133 : 0 : pr_warn("Cannot find property name at 0x%x\n", cur);
134 : 0 : continue;
135 : : }
136 : :
137 : 3 : if (!strcmp(pname, "name"))
138 : : has_name = true;
139 : :
140 : : pp = unflatten_dt_alloc(mem, sizeof(struct property),
141 : : __alignof__(struct property));
142 : 3 : if (dryrun)
143 : 3 : continue;
144 : :
145 : : /* We accept flattened tree phandles either in
146 : : * ePAPR-style "phandle" properties, or the
147 : : * legacy "linux,phandle" properties. If both
148 : : * appear and have different values, things
149 : : * will get weird. Don't do that.
150 : : */
151 : 3 : if (!strcmp(pname, "phandle") ||
152 : 3 : !strcmp(pname, "linux,phandle")) {
153 : 3 : if (!np->phandle)
154 : 3 : np->phandle = be32_to_cpup(val);
155 : : }
156 : :
157 : : /* And we process the "ibm,phandle" property
158 : : * used in pSeries dynamic device tree
159 : : * stuff
160 : : */
161 : 3 : if (!strcmp(pname, "ibm,phandle"))
162 : 0 : np->phandle = be32_to_cpup(val);
163 : :
164 : 3 : pp->name = (char *)pname;
165 : 3 : pp->length = sz;
166 : 3 : pp->value = (__be32 *)val;
167 : 3 : *pprev = pp;
168 : 3 : pprev = &pp->next;
169 : : }
170 : :
171 : : /* With version 0x10 we may not have the name property,
172 : : * recreate it here from the unit name if absent
173 : : */
174 : 3 : if (!has_name) {
175 : : const char *p = nodename, *ps = p, *pa = NULL;
176 : : int len;
177 : :
178 : 3 : while (*p) {
179 : 3 : if ((*p) == '@')
180 : : pa = p;
181 : 3 : else if ((*p) == '/')
182 : 0 : ps = p + 1;
183 : 3 : p++;
184 : : }
185 : :
186 : 3 : if (pa < ps)
187 : 3 : pa = p;
188 : 3 : len = (pa - ps) + 1;
189 : 3 : pp = unflatten_dt_alloc(mem, sizeof(struct property) + len,
190 : : __alignof__(struct property));
191 : 3 : if (!dryrun) {
192 : 3 : pp->name = "name";
193 : 3 : pp->length = len;
194 : 3 : pp->value = pp + 1;
195 : 3 : *pprev = pp;
196 : 3 : pprev = &pp->next;
197 : 3 : memcpy(pp->value, ps, len - 1);
198 : 3 : ((char *)pp->value)[len - 1] = 0;
199 : : pr_debug("fixed up name for %s -> %s\n",
200 : : nodename, (char *)pp->value);
201 : : }
202 : : }
203 : :
204 : 3 : if (!dryrun)
205 : 3 : *pprev = NULL;
206 : 3 : }
207 : :
208 : 3 : static bool populate_node(const void *blob,
209 : : int offset,
210 : : void **mem,
211 : : struct device_node *dad,
212 : : struct device_node **pnp,
213 : : bool dryrun)
214 : : {
215 : : struct device_node *np;
216 : : const char *pathp;
217 : : unsigned int l, allocl;
218 : :
219 : 3 : pathp = fdt_get_name(blob, offset, &l);
220 : 3 : if (!pathp) {
221 : 0 : *pnp = NULL;
222 : 0 : return false;
223 : : }
224 : :
225 : 3 : allocl = ++l;
226 : :
227 : 3 : np = unflatten_dt_alloc(mem, sizeof(struct device_node) + allocl,
228 : : __alignof__(struct device_node));
229 : 3 : if (!dryrun) {
230 : : char *fn;
231 : : of_node_init(np);
232 : 3 : np->full_name = fn = ((char *)np) + sizeof(*np);
233 : :
234 : 3 : memcpy(fn, pathp, l);
235 : :
236 : 3 : if (dad != NULL) {
237 : 3 : np->parent = dad;
238 : 3 : np->sibling = dad->child;
239 : 3 : dad->child = np;
240 : : }
241 : : }
242 : :
243 : 3 : populate_properties(blob, offset, mem, np, pathp, dryrun);
244 : 3 : if (!dryrun) {
245 : 3 : np->name = of_get_property(np, "name", NULL);
246 : 3 : if (!np->name)
247 : 0 : np->name = "<NULL>";
248 : : }
249 : :
250 : 3 : *pnp = np;
251 : 3 : return true;
252 : : }
253 : :
254 : 3 : static void reverse_nodes(struct device_node *parent)
255 : : {
256 : : struct device_node *child, *next;
257 : :
258 : : /* In-depth first */
259 : 3 : child = parent->child;
260 : 3 : while (child) {
261 : 3 : reverse_nodes(child);
262 : :
263 : 3 : child = child->sibling;
264 : : }
265 : :
266 : : /* Reverse the nodes in the child list */
267 : 3 : child = parent->child;
268 : 3 : parent->child = NULL;
269 : 3 : while (child) {
270 : 3 : next = child->sibling;
271 : :
272 : 3 : child->sibling = parent->child;
273 : 3 : parent->child = child;
274 : : child = next;
275 : : }
276 : 3 : }
277 : :
278 : : /**
279 : : * unflatten_dt_nodes - Alloc and populate a device_node from the flat tree
280 : : * @blob: The parent device tree blob
281 : : * @mem: Memory chunk to use for allocating device nodes and properties
282 : : * @dad: Parent struct device_node
283 : : * @nodepp: The device_node tree created by the call
284 : : *
285 : : * It returns the size of unflattened device tree or error code
286 : : */
287 : 3 : static int unflatten_dt_nodes(const void *blob,
288 : : void *mem,
289 : : struct device_node *dad,
290 : : struct device_node **nodepp)
291 : : {
292 : : struct device_node *root;
293 : 3 : int offset = 0, depth = 0, initial_depth = 0;
294 : : #define FDT_MAX_DEPTH 64
295 : : struct device_node *nps[FDT_MAX_DEPTH];
296 : 3 : void *base = mem;
297 : 3 : bool dryrun = !base;
298 : :
299 : 3 : if (nodepp)
300 : 3 : *nodepp = NULL;
301 : :
302 : : /*
303 : : * We're unflattening device sub-tree if @dad is valid. There are
304 : : * possibly multiple nodes in the first level of depth. We need
305 : : * set @depth to 1 to make fdt_next_node() happy as it bails
306 : : * immediately when negative @depth is found. Otherwise, the device
307 : : * nodes except the first one won't be unflattened successfully.
308 : : */
309 : 3 : if (dad)
310 : 0 : depth = initial_depth = 1;
311 : :
312 : : root = dad;
313 : 3 : nps[depth] = dad;
314 : :
315 : 3 : for (offset = 0;
316 : 3 : offset >= 0 && depth >= initial_depth;
317 : 3 : offset = fdt_next_node(blob, offset, &depth)) {
318 : 3 : if (WARN_ON_ONCE(depth >= FDT_MAX_DEPTH))
319 : 0 : continue;
320 : :
321 : : if (!IS_ENABLED(CONFIG_OF_KOBJ) &&
322 : : !of_fdt_device_is_available(blob, offset))
323 : : continue;
324 : :
325 : 3 : if (!populate_node(blob, offset, &mem, nps[depth],
326 : 3 : &nps[depth+1], dryrun))
327 : 0 : return mem - base;
328 : :
329 : 3 : if (!dryrun && nodepp && !*nodepp)
330 : 3 : *nodepp = nps[depth+1];
331 : 3 : if (!dryrun && !root)
332 : 3 : root = nps[depth+1];
333 : : }
334 : :
335 : 3 : if (offset < 0 && offset != -FDT_ERR_NOTFOUND) {
336 : 0 : pr_err("Error %d processing FDT\n", offset);
337 : 0 : return -EINVAL;
338 : : }
339 : :
340 : : /*
341 : : * Reverse the child list. Some drivers assumes node order matches .dts
342 : : * node order
343 : : */
344 : 3 : if (!dryrun)
345 : 3 : reverse_nodes(root);
346 : :
347 : 3 : return mem - base;
348 : : }
349 : :
350 : : /**
351 : : * __unflatten_device_tree - create tree of device_nodes from flat blob
352 : : *
353 : : * unflattens a device-tree, creating the
354 : : * tree of struct device_node. It also fills the "name" and "type"
355 : : * pointers of the nodes so the normal device-tree walking functions
356 : : * can be used.
357 : : * @blob: The blob to expand
358 : : * @dad: Parent device node
359 : : * @mynodes: The device_node tree created by the call
360 : : * @dt_alloc: An allocator that provides a virtual address to memory
361 : : * for the resulting tree
362 : : * @detached: if true set OF_DETACHED on @mynodes
363 : : *
364 : : * Returns NULL on failure or the memory chunk containing the unflattened
365 : : * device tree on success.
366 : : */
367 : 3 : void *__unflatten_device_tree(const void *blob,
368 : : struct device_node *dad,
369 : : struct device_node **mynodes,
370 : : void *(*dt_alloc)(u64 size, u64 align),
371 : : bool detached)
372 : : {
373 : : int size;
374 : : void *mem;
375 : :
376 : : pr_debug(" -> unflatten_device_tree()\n");
377 : :
378 : 3 : if (!blob) {
379 : : pr_debug("No device tree pointer\n");
380 : : return NULL;
381 : : }
382 : :
383 : : pr_debug("Unflattening device tree:\n");
384 : : pr_debug("magic: %08x\n", fdt_magic(blob));
385 : : pr_debug("size: %08x\n", fdt_totalsize(blob));
386 : : pr_debug("version: %08x\n", fdt_version(blob));
387 : :
388 : 3 : if (fdt_check_header(blob)) {
389 : 0 : pr_err("Invalid device tree blob header\n");
390 : 0 : return NULL;
391 : : }
392 : :
393 : : /* First pass, scan for size */
394 : 3 : size = unflatten_dt_nodes(blob, NULL, dad, NULL);
395 : 3 : if (size < 0)
396 : : return NULL;
397 : :
398 : 3 : size = ALIGN(size, 4);
399 : : pr_debug(" size is %d, allocating...\n", size);
400 : :
401 : : /* Allocate memory for the expanded device tree */
402 : 3 : mem = dt_alloc(size + 4, __alignof__(struct device_node));
403 : 3 : if (!mem)
404 : : return NULL;
405 : :
406 : 3 : memset(mem, 0, size);
407 : :
408 : 3 : *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
409 : :
410 : : pr_debug(" unflattening %p...\n", mem);
411 : :
412 : : /* Second pass, do actual unflattening */
413 : 3 : unflatten_dt_nodes(blob, mem, dad, mynodes);
414 : 3 : if (be32_to_cpup(mem + size) != 0xdeadbeef)
415 : 0 : pr_warning("End of tree marker overwritten: %08x\n",
416 : : be32_to_cpup(mem + size));
417 : :
418 : 3 : if (detached && mynodes) {
419 : 0 : of_node_set_flag(*mynodes, OF_DETACHED);
420 : : pr_debug("unflattened tree is detached\n");
421 : : }
422 : :
423 : : pr_debug(" <- unflatten_device_tree()\n");
424 : 3 : return mem;
425 : : }
426 : :
427 : 0 : static void *kernel_tree_alloc(u64 size, u64 align)
428 : : {
429 : 0 : return kzalloc(size, GFP_KERNEL);
430 : : }
431 : :
432 : : static DEFINE_MUTEX(of_fdt_unflatten_mutex);
433 : :
434 : : /**
435 : : * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
436 : : * @blob: Flat device tree blob
437 : : * @dad: Parent device node
438 : : * @mynodes: The device tree created by the call
439 : : *
440 : : * unflattens the device-tree passed by the firmware, creating the
441 : : * tree of struct device_node. It also fills the "name" and "type"
442 : : * pointers of the nodes so the normal device-tree walking functions
443 : : * can be used.
444 : : *
445 : : * Returns NULL on failure or the memory chunk containing the unflattened
446 : : * device tree on success.
447 : : */
448 : 0 : void *of_fdt_unflatten_tree(const unsigned long *blob,
449 : : struct device_node *dad,
450 : : struct device_node **mynodes)
451 : : {
452 : : void *mem;
453 : :
454 : 0 : mutex_lock(&of_fdt_unflatten_mutex);
455 : 0 : mem = __unflatten_device_tree(blob, dad, mynodes, &kernel_tree_alloc,
456 : : true);
457 : 0 : mutex_unlock(&of_fdt_unflatten_mutex);
458 : :
459 : 0 : return mem;
460 : : }
461 : : EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree);
462 : :
463 : : /* Everything below here references initial_boot_params directly. */
464 : : int __initdata dt_root_addr_cells;
465 : : int __initdata dt_root_size_cells;
466 : :
467 : : void *initial_boot_params __ro_after_init;
468 : :
469 : : #ifdef CONFIG_OF_EARLY_FLATTREE
470 : :
471 : : static u32 of_fdt_crc32;
472 : :
473 : : /**
474 : : * res_mem_reserve_reg() - reserve all memory described in 'reg' property
475 : : */
476 : 3 : static int __init __reserved_mem_reserve_reg(unsigned long node,
477 : : const char *uname)
478 : : {
479 : 3 : int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
480 : : phys_addr_t base, size;
481 : : int len;
482 : : const __be32 *prop;
483 : : int first = 1;
484 : : bool nomap;
485 : :
486 : 3 : prop = of_get_flat_dt_prop(node, "reg", &len);
487 : 3 : if (!prop)
488 : : return -ENOENT;
489 : :
490 : 0 : if (len && len % t_len != 0) {
491 : 0 : pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
492 : : uname);
493 : 0 : return -EINVAL;
494 : : }
495 : :
496 : 0 : nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
497 : :
498 : 0 : while (len >= t_len) {
499 : 0 : base = dt_mem_next_cell(dt_root_addr_cells, &prop);
500 : 0 : size = dt_mem_next_cell(dt_root_size_cells, &prop);
501 : :
502 : 0 : if (size &&
503 : 0 : early_init_dt_reserve_memory_arch(base, size, nomap) == 0)
504 : : pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n",
505 : : uname, &base, (unsigned long)size / SZ_1M);
506 : : else
507 : 0 : pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n",
508 : : uname, &base, (unsigned long)size / SZ_1M);
509 : :
510 : 0 : len -= t_len;
511 : 0 : if (first) {
512 : 0 : fdt_reserved_mem_save_node(node, uname, base, size);
513 : : first = 0;
514 : : }
515 : : }
516 : : return 0;
517 : : }
518 : :
519 : : /**
520 : : * __reserved_mem_check_root() - check if #size-cells, #address-cells provided
521 : : * in /reserved-memory matches the values supported by the current implementation,
522 : : * also check if ranges property has been provided
523 : : */
524 : 3 : static int __init __reserved_mem_check_root(unsigned long node)
525 : : {
526 : : const __be32 *prop;
527 : :
528 : 3 : prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
529 : 3 : if (!prop || be32_to_cpup(prop) != dt_root_size_cells)
530 : : return -EINVAL;
531 : :
532 : 3 : prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
533 : 3 : if (!prop || be32_to_cpup(prop) != dt_root_addr_cells)
534 : : return -EINVAL;
535 : :
536 : 3 : prop = of_get_flat_dt_prop(node, "ranges", NULL);
537 : 3 : if (!prop)
538 : : return -EINVAL;
539 : 3 : return 0;
540 : : }
541 : :
542 : : /**
543 : : * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
544 : : */
545 : 3 : static int __init __fdt_scan_reserved_mem(unsigned long node, const char *uname,
546 : : int depth, void *data)
547 : : {
548 : : static int found;
549 : : int err;
550 : :
551 : 3 : if (!found && depth == 1 && strcmp(uname, "reserved-memory") == 0) {
552 : 3 : if (__reserved_mem_check_root(node) != 0) {
553 : 0 : pr_err("Reserved memory: unsupported node format, ignoring\n");
554 : : /* break scan */
555 : 0 : return 1;
556 : : }
557 : 3 : found = 1;
558 : : /* scan next node */
559 : 3 : return 0;
560 : 3 : } else if (!found) {
561 : : /* scan next node */
562 : : return 0;
563 : 3 : } else if (found && depth < 2) {
564 : : /* scanning of /reserved-memory has been finished */
565 : : return 1;
566 : : }
567 : :
568 : 3 : if (!of_fdt_device_is_available(initial_boot_params, node))
569 : : return 0;
570 : :
571 : 3 : err = __reserved_mem_reserve_reg(node, uname);
572 : 3 : if (err == -ENOENT && of_get_flat_dt_prop(node, "size", NULL))
573 : 3 : fdt_reserved_mem_save_node(node, uname, 0, 0);
574 : :
575 : : /* scan next node */
576 : : return 0;
577 : : }
578 : :
579 : : /**
580 : : * early_init_fdt_scan_reserved_mem() - create reserved memory regions
581 : : *
582 : : * This function grabs memory from early allocator for device exclusive use
583 : : * defined in device tree structures. It should be called by arch specific code
584 : : * once the early allocator (i.e. memblock) has been fully activated.
585 : : */
586 : 3 : void __init early_init_fdt_scan_reserved_mem(void)
587 : : {
588 : : int n;
589 : : u64 base, size;
590 : :
591 : 3 : if (!initial_boot_params)
592 : 0 : return;
593 : :
594 : : /* Process header /memreserve/ fields */
595 : 3 : for (n = 0; ; n++) {
596 : 3 : fdt_get_mem_rsv(initial_boot_params, n, &base, &size);
597 : 3 : if (!size)
598 : : break;
599 : 3 : early_init_dt_reserve_memory_arch(base, size, false);
600 : 3 : }
601 : :
602 : 3 : of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
603 : 3 : fdt_init_reserved_mem();
604 : : }
605 : :
606 : : /**
607 : : * early_init_fdt_reserve_self() - reserve the memory used by the FDT blob
608 : : */
609 : 3 : void __init early_init_fdt_reserve_self(void)
610 : : {
611 : 3 : if (!initial_boot_params)
612 : 3 : return;
613 : :
614 : : /* Reserve the dtb region */
615 : 3 : early_init_dt_reserve_memory_arch(__pa(initial_boot_params),
616 : : fdt_totalsize(initial_boot_params),
617 : : false);
618 : : }
619 : :
620 : : /**
621 : : * of_scan_flat_dt - scan flattened tree blob and call callback on each.
622 : : * @it: callback function
623 : : * @data: context data pointer
624 : : *
625 : : * This function is used to scan the flattened device-tree, it is
626 : : * used to extract the memory information at boot before we can
627 : : * unflatten the tree
628 : : */
629 : 3 : int __init of_scan_flat_dt(int (*it)(unsigned long node,
630 : : const char *uname, int depth,
631 : : void *data),
632 : : void *data)
633 : : {
634 : 3 : const void *blob = initial_boot_params;
635 : : const char *pathp;
636 : 3 : int offset, rc = 0, depth = -1;
637 : :
638 : 3 : if (!blob)
639 : : return 0;
640 : :
641 : 3 : for (offset = fdt_next_node(blob, -1, &depth);
642 : 3 : offset >= 0 && depth >= 0 && !rc;
643 : 3 : offset = fdt_next_node(blob, offset, &depth)) {
644 : :
645 : 3 : pathp = fdt_get_name(blob, offset, NULL);
646 : 3 : if (*pathp == '/')
647 : : pathp = kbasename(pathp);
648 : 3 : rc = it(offset, pathp, depth, data);
649 : : }
650 : 3 : return rc;
651 : : }
652 : :
653 : : /**
654 : : * of_scan_flat_dt_subnodes - scan sub-nodes of a node call callback on each.
655 : : * @it: callback function
656 : : * @data: context data pointer
657 : : *
658 : : * This function is used to scan sub-nodes of a node.
659 : : */
660 : 0 : int __init of_scan_flat_dt_subnodes(unsigned long parent,
661 : : int (*it)(unsigned long node,
662 : : const char *uname,
663 : : void *data),
664 : : void *data)
665 : : {
666 : 0 : const void *blob = initial_boot_params;
667 : : int node;
668 : :
669 : 0 : fdt_for_each_subnode(node, blob, parent) {
670 : : const char *pathp;
671 : : int rc;
672 : :
673 : 0 : pathp = fdt_get_name(blob, node, NULL);
674 : 0 : if (*pathp == '/')
675 : : pathp = kbasename(pathp);
676 : 0 : rc = it(node, pathp, data);
677 : 0 : if (rc)
678 : 0 : return rc;
679 : : }
680 : : return 0;
681 : : }
682 : :
683 : : /**
684 : : * of_get_flat_dt_subnode_by_name - get the subnode by given name
685 : : *
686 : : * @node: the parent node
687 : : * @uname: the name of subnode
688 : : * @return offset of the subnode, or -FDT_ERR_NOTFOUND if there is none
689 : : */
690 : :
691 : 3 : int __init of_get_flat_dt_subnode_by_name(unsigned long node, const char *uname)
692 : : {
693 : 3 : return fdt_subnode_offset(initial_boot_params, node, uname);
694 : : }
695 : :
696 : : /**
697 : : * of_get_flat_dt_root - find the root node in the flat blob
698 : : */
699 : 3 : unsigned long __init of_get_flat_dt_root(void)
700 : : {
701 : 3 : return 0;
702 : : }
703 : :
704 : : /**
705 : : * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
706 : : *
707 : : * This function can be used within scan_flattened_dt callback to get
708 : : * access to properties
709 : : */
710 : 3 : const void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
711 : : int *size)
712 : : {
713 : 3 : return fdt_getprop(initial_boot_params, node, name, size);
714 : : }
715 : :
716 : : /**
717 : : * of_fdt_is_compatible - Return true if given node from the given blob has
718 : : * compat in its compatible list
719 : : * @blob: A device tree blob
720 : : * @node: node to test
721 : : * @compat: compatible string to compare with compatible list.
722 : : *
723 : : * On match, returns a non-zero value with smaller values returned for more
724 : : * specific compatible values.
725 : : */
726 : 3 : static int of_fdt_is_compatible(const void *blob,
727 : : unsigned long node, const char *compat)
728 : : {
729 : : const char *cp;
730 : : int cplen;
731 : : unsigned long l, score = 0;
732 : :
733 : 3 : cp = fdt_getprop(blob, node, "compatible", &cplen);
734 : 3 : if (cp == NULL)
735 : : return 0;
736 : 3 : while (cplen > 0) {
737 : 3 : score++;
738 : 3 : if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
739 : 3 : return score;
740 : 3 : l = strlen(cp) + 1;
741 : 3 : cp += l;
742 : 3 : cplen -= l;
743 : : }
744 : :
745 : : return 0;
746 : : }
747 : :
748 : : /**
749 : : * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
750 : : * @node: node to test
751 : : * @compat: compatible string to compare with compatible list.
752 : : */
753 : 3 : int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
754 : : {
755 : 3 : return of_fdt_is_compatible(initial_boot_params, node, compat);
756 : : }
757 : :
758 : : /**
759 : : * of_flat_dt_match - Return true if node matches a list of compatible values
760 : : */
761 : 3 : static int __init of_flat_dt_match(unsigned long node, const char *const *compat)
762 : : {
763 : : unsigned int tmp, score = 0;
764 : :
765 : 3 : if (!compat)
766 : : return 0;
767 : :
768 : 3 : while (*compat) {
769 : 3 : tmp = of_fdt_is_compatible(initial_boot_params, node, *compat);
770 : 3 : if (tmp && (score == 0 || (tmp < score)))
771 : : score = tmp;
772 : 3 : compat++;
773 : : }
774 : :
775 : 3 : return score;
776 : : }
777 : :
778 : : /**
779 : : * of_get_flat_dt_prop - Given a node in the flat blob, return the phandle
780 : : */
781 : 0 : uint32_t __init of_get_flat_dt_phandle(unsigned long node)
782 : : {
783 : 0 : return fdt_get_phandle(initial_boot_params, node);
784 : : }
785 : :
786 : : struct fdt_scan_status {
787 : : const char *name;
788 : : int namelen;
789 : : int depth;
790 : : int found;
791 : : int (*iterator)(unsigned long node, const char *uname, int depth, void *data);
792 : : void *data;
793 : : };
794 : :
795 : 3 : const char * __init of_flat_dt_get_machine_name(void)
796 : : {
797 : : const char *name;
798 : : unsigned long dt_root = of_get_flat_dt_root();
799 : :
800 : 3 : name = of_get_flat_dt_prop(dt_root, "model", NULL);
801 : 3 : if (!name)
802 : 0 : name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
803 : 3 : return name;
804 : : }
805 : :
806 : : /**
807 : : * of_flat_dt_match_machine - Iterate match tables to find matching machine.
808 : : *
809 : : * @default_match: A machine specific ptr to return in case of no match.
810 : : * @get_next_compat: callback function to return next compatible match table.
811 : : *
812 : : * Iterate through machine match tables to find the best match for the machine
813 : : * compatible string in the FDT.
814 : : */
815 : 3 : const void * __init of_flat_dt_match_machine(const void *default_match,
816 : : const void * (*get_next_compat)(const char * const**))
817 : : {
818 : : const void *data = NULL;
819 : : const void *best_data = default_match;
820 : : const char *const *compat;
821 : : unsigned long dt_root;
822 : : unsigned int best_score = ~1, score = 0;
823 : :
824 : : dt_root = of_get_flat_dt_root();
825 : 3 : while ((data = get_next_compat(&compat))) {
826 : 3 : score = of_flat_dt_match(dt_root, compat);
827 : 3 : if (score > 0 && score < best_score) {
828 : : best_data = data;
829 : : best_score = score;
830 : : }
831 : : }
832 : 3 : if (!best_data) {
833 : : const char *prop;
834 : : int size;
835 : :
836 : 0 : pr_err("\n unrecognized device tree list:\n[ ");
837 : :
838 : 0 : prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
839 : 0 : if (prop) {
840 : 0 : while (size > 0) {
841 : 0 : printk("'%s' ", prop);
842 : 0 : size -= strlen(prop) + 1;
843 : 0 : prop += strlen(prop) + 1;
844 : : }
845 : : }
846 : 0 : printk("]\n\n");
847 : : return NULL;
848 : : }
849 : :
850 : 3 : pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
851 : :
852 : 3 : return best_data;
853 : : }
854 : :
855 : : #ifdef CONFIG_BLK_DEV_INITRD
856 : 0 : static void __early_init_dt_declare_initrd(unsigned long start,
857 : : unsigned long end)
858 : : {
859 : : /* ARM64 would cause a BUG to occur here when CONFIG_DEBUG_VM is
860 : : * enabled since __va() is called too early. ARM64 does make use
861 : : * of phys_initrd_start/phys_initrd_size so we can skip this
862 : : * conversion.
863 : : */
864 : : if (!IS_ENABLED(CONFIG_ARM64)) {
865 : 0 : initrd_start = (unsigned long)__va(start);
866 : 0 : initrd_end = (unsigned long)__va(end);
867 : 0 : initrd_below_start_ok = 1;
868 : : }
869 : 0 : }
870 : :
871 : : /**
872 : : * early_init_dt_check_for_initrd - Decode initrd location from flat tree
873 : : * @node: reference to node containing initrd location ('chosen')
874 : : */
875 : 3 : static void __init early_init_dt_check_for_initrd(unsigned long node)
876 : : {
877 : : u64 start, end;
878 : : int len;
879 : : const __be32 *prop;
880 : :
881 : : pr_debug("Looking for initrd properties... ");
882 : :
883 : 3 : prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
884 : 3 : if (!prop)
885 : 3 : return;
886 : 0 : start = of_read_number(prop, len/4);
887 : :
888 : 0 : prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
889 : 0 : if (!prop)
890 : : return;
891 : 0 : end = of_read_number(prop, len/4);
892 : :
893 : 0 : __early_init_dt_declare_initrd(start, end);
894 : 0 : phys_initrd_start = start;
895 : 0 : phys_initrd_size = end - start;
896 : :
897 : : pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
898 : : (unsigned long long)start, (unsigned long long)end);
899 : : }
900 : : #else
901 : : static inline void early_init_dt_check_for_initrd(unsigned long node)
902 : : {
903 : : }
904 : : #endif /* CONFIG_BLK_DEV_INITRD */
905 : :
906 : : #ifdef CONFIG_SERIAL_EARLYCON
907 : :
908 : 0 : int __init early_init_dt_scan_chosen_stdout(void)
909 : : {
910 : : int offset;
911 : : const char *p, *q, *options = NULL;
912 : : int l;
913 : : const struct earlycon_id **p_match;
914 : 0 : const void *fdt = initial_boot_params;
915 : :
916 : 0 : offset = fdt_path_offset(fdt, "/chosen");
917 : 0 : if (offset < 0)
918 : 0 : offset = fdt_path_offset(fdt, "/chosen@0");
919 : 0 : if (offset < 0)
920 : : return -ENOENT;
921 : :
922 : 0 : p = fdt_getprop(fdt, offset, "stdout-path", &l);
923 : 0 : if (!p)
924 : 0 : p = fdt_getprop(fdt, offset, "linux,stdout-path", &l);
925 : 0 : if (!p || !l)
926 : : return -ENOENT;
927 : :
928 : 0 : q = strchrnul(p, ':');
929 : 0 : if (*q != '\0')
930 : 0 : options = q + 1;
931 : 0 : l = q - p;
932 : :
933 : : /* Get the node specified by stdout-path */
934 : 0 : offset = fdt_path_offset_namelen(fdt, p, l);
935 : 0 : if (offset < 0) {
936 : 0 : pr_warn("earlycon: stdout-path %.*s not found\n", l, p);
937 : 0 : return 0;
938 : : }
939 : :
940 : 0 : for (p_match = __earlycon_table; p_match < __earlycon_table_end;
941 : 0 : p_match++) {
942 : 0 : const struct earlycon_id *match = *p_match;
943 : :
944 : 0 : if (!match->compatible[0])
945 : 0 : continue;
946 : :
947 : 0 : if (fdt_node_check_compatible(fdt, offset, match->compatible))
948 : 0 : continue;
949 : :
950 : 0 : of_setup_earlycon(match, offset, options);
951 : 0 : return 0;
952 : : }
953 : : return -ENODEV;
954 : : }
955 : : #endif
956 : :
957 : : /**
958 : : * early_init_dt_scan_root - fetch the top level address and size cells
959 : : */
960 : 3 : int __init early_init_dt_scan_root(unsigned long node, const char *uname,
961 : : int depth, void *data)
962 : : {
963 : : const __be32 *prop;
964 : :
965 : 3 : if (depth != 0)
966 : : return 0;
967 : :
968 : 3 : dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
969 : 3 : dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
970 : :
971 : 3 : prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
972 : 3 : if (prop)
973 : 3 : dt_root_size_cells = be32_to_cpup(prop);
974 : : pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
975 : :
976 : 3 : prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
977 : 3 : if (prop)
978 : 3 : dt_root_addr_cells = be32_to_cpup(prop);
979 : : pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
980 : :
981 : : /* break now */
982 : : return 1;
983 : : }
984 : :
985 : 3 : u64 __init dt_mem_next_cell(int s, const __be32 **cellp)
986 : : {
987 : 3 : const __be32 *p = *cellp;
988 : :
989 : 3 : *cellp = p + s;
990 : 3 : return of_read_number(p, s);
991 : : }
992 : :
993 : : /**
994 : : * early_init_dt_scan_memory - Look for and parse memory nodes
995 : : */
996 : 3 : int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
997 : : int depth, void *data)
998 : : {
999 : 3 : const char *type = of_get_flat_dt_prop(node, "device_type", NULL);
1000 : : const __be32 *reg, *endp;
1001 : : int l;
1002 : : bool hotpluggable;
1003 : :
1004 : : /* We are scanning "memory" nodes only */
1005 : 3 : if (type == NULL || strcmp(type, "memory") != 0)
1006 : : return 0;
1007 : :
1008 : 3 : reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
1009 : 3 : if (reg == NULL)
1010 : 3 : reg = of_get_flat_dt_prop(node, "reg", &l);
1011 : 3 : if (reg == NULL)
1012 : : return 0;
1013 : :
1014 : 3 : endp = reg + (l / sizeof(__be32));
1015 : 3 : hotpluggable = of_get_flat_dt_prop(node, "hotpluggable", NULL);
1016 : :
1017 : : pr_debug("memory scan node %s, reg size %d,\n", uname, l);
1018 : :
1019 : 3 : while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
1020 : : u64 base, size;
1021 : :
1022 : 3 : base = dt_mem_next_cell(dt_root_addr_cells, ®);
1023 : 3 : size = dt_mem_next_cell(dt_root_size_cells, ®);
1024 : :
1025 : 3 : if (size == 0)
1026 : 0 : continue;
1027 : : pr_debug(" - %llx , %llx\n", (unsigned long long)base,
1028 : : (unsigned long long)size);
1029 : :
1030 : 3 : early_init_dt_add_memory_arch(base, size);
1031 : :
1032 : 3 : if (!hotpluggable)
1033 : 3 : continue;
1034 : :
1035 : 0 : if (early_init_dt_mark_hotplug_memory_arch(base, size))
1036 : 0 : pr_warn("failed to mark hotplug range 0x%llx - 0x%llx\n",
1037 : : base, base + size);
1038 : : }
1039 : :
1040 : : return 0;
1041 : : }
1042 : :
1043 : 3 : int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
1044 : : int depth, void *data)
1045 : : {
1046 : : int l;
1047 : : const char *p;
1048 : : const void *rng_seed;
1049 : :
1050 : : pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
1051 : :
1052 : 3 : if (depth != 1 || !data ||
1053 : 3 : (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
1054 : : return 0;
1055 : :
1056 : 3 : early_init_dt_check_for_initrd(node);
1057 : :
1058 : : /* Retrieve command line */
1059 : 3 : p = of_get_flat_dt_prop(node, "bootargs", &l);
1060 : 3 : if (p != NULL && l > 0)
1061 : 3 : strlcpy(data, p, min(l, COMMAND_LINE_SIZE));
1062 : :
1063 : : /*
1064 : : * CONFIG_CMDLINE is meant to be a default in case nothing else
1065 : : * managed to set the command line, unless CONFIG_CMDLINE_FORCE
1066 : : * is set in which case we override whatever was found earlier.
1067 : : */
1068 : : #ifdef CONFIG_CMDLINE
1069 : : #if defined(CONFIG_CMDLINE_EXTEND)
1070 : : strlcat(data, " ", COMMAND_LINE_SIZE);
1071 : : strlcat(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
1072 : : #elif defined(CONFIG_CMDLINE_FORCE)
1073 : : strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
1074 : : #else
1075 : : /* No arguments from boot loader, use kernel's cmdl*/
1076 : 3 : if (!((char *)data)[0])
1077 : 0 : strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
1078 : : #endif
1079 : : #endif /* CONFIG_CMDLINE */
1080 : :
1081 : : pr_debug("Command line is: %s\n", (char*)data);
1082 : :
1083 : 3 : rng_seed = of_get_flat_dt_prop(node, "rng-seed", &l);
1084 : 3 : if (rng_seed && l > 0) {
1085 : 0 : add_bootloader_randomness(rng_seed, l);
1086 : :
1087 : : /* try to clear seed so it won't be found. */
1088 : 0 : fdt_nop_property(initial_boot_params, node, "rng-seed");
1089 : :
1090 : : /* update CRC check value */
1091 : 0 : of_fdt_crc32 = crc32_be(~0, initial_boot_params,
1092 : 0 : fdt_totalsize(initial_boot_params));
1093 : : }
1094 : :
1095 : : /* break now */
1096 : : return 1;
1097 : : }
1098 : :
1099 : : #ifndef MIN_MEMBLOCK_ADDR
1100 : : #define MIN_MEMBLOCK_ADDR __pa(PAGE_OFFSET)
1101 : : #endif
1102 : : #ifndef MAX_MEMBLOCK_ADDR
1103 : : #define MAX_MEMBLOCK_ADDR ((phys_addr_t)~0)
1104 : : #endif
1105 : :
1106 : 3 : void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
1107 : : {
1108 : 3 : const u64 phys_offset = MIN_MEMBLOCK_ADDR;
1109 : :
1110 : 3 : if (size < PAGE_SIZE - (base & ~PAGE_MASK)) {
1111 : 0 : pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1112 : : base, base + size);
1113 : 0 : return;
1114 : : }
1115 : :
1116 : 3 : if (!PAGE_ALIGNED(base)) {
1117 : 0 : size -= PAGE_SIZE - (base & ~PAGE_MASK);
1118 : 0 : base = PAGE_ALIGN(base);
1119 : : }
1120 : 3 : size &= PAGE_MASK;
1121 : :
1122 : 3 : if (base > MAX_MEMBLOCK_ADDR) {
1123 : 0 : pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
1124 : : base, base + size);
1125 : 0 : return;
1126 : : }
1127 : :
1128 : 3 : if (base + size - 1 > MAX_MEMBLOCK_ADDR) {
1129 : 0 : pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
1130 : : ((u64)MAX_MEMBLOCK_ADDR) + 1, base + size);
1131 : 0 : size = MAX_MEMBLOCK_ADDR - base + 1;
1132 : : }
1133 : :
1134 : 3 : if (base + size < phys_offset) {
1135 : 0 : pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
1136 : : base, base + size);
1137 : 0 : return;
1138 : : }
1139 : 3 : if (base < phys_offset) {
1140 : 0 : pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
1141 : : base, phys_offset);
1142 : 0 : size -= phys_offset - base;
1143 : : base = phys_offset;
1144 : : }
1145 : 3 : memblock_add(base, size);
1146 : : }
1147 : :
1148 : 0 : int __init __weak early_init_dt_mark_hotplug_memory_arch(u64 base, u64 size)
1149 : : {
1150 : 0 : return memblock_mark_hotplug(base, size);
1151 : : }
1152 : :
1153 : 3 : int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base,
1154 : : phys_addr_t size, bool nomap)
1155 : : {
1156 : 3 : if (nomap)
1157 : 0 : return memblock_remove(base, size);
1158 : 3 : return memblock_reserve(base, size);
1159 : : }
1160 : :
1161 : 3 : static void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
1162 : : {
1163 : 3 : void *ptr = memblock_alloc(size, align);
1164 : :
1165 : 3 : if (!ptr)
1166 : 0 : panic("%s: Failed to allocate %llu bytes align=0x%llx\n",
1167 : : __func__, size, align);
1168 : :
1169 : 3 : return ptr;
1170 : : }
1171 : :
1172 : 3 : bool __init early_init_dt_verify(void *params)
1173 : : {
1174 : 3 : if (!params)
1175 : : return false;
1176 : :
1177 : : /* check device tree validity */
1178 : 3 : if (fdt_check_header(params))
1179 : : return false;
1180 : :
1181 : : /* Setup flat device-tree pointer */
1182 : 3 : initial_boot_params = params;
1183 : 3 : of_fdt_crc32 = crc32_be(~0, initial_boot_params,
1184 : : fdt_totalsize(initial_boot_params));
1185 : 3 : return true;
1186 : : }
1187 : :
1188 : :
1189 : 3 : void __init early_init_dt_scan_nodes(void)
1190 : : {
1191 : : int rc = 0;
1192 : :
1193 : : /* Retrieve various information from the /chosen node */
1194 : 3 : rc = of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
1195 : 3 : if (!rc)
1196 : 0 : pr_warn("No chosen node found, continuing without\n");
1197 : :
1198 : : /* Initialize {size,address}-cells info */
1199 : 3 : of_scan_flat_dt(early_init_dt_scan_root, NULL);
1200 : :
1201 : : /* Setup memory, calling early_init_dt_add_memory_arch */
1202 : 3 : of_scan_flat_dt(early_init_dt_scan_memory, NULL);
1203 : 3 : }
1204 : :
1205 : 0 : bool __init early_init_dt_scan(void *params)
1206 : : {
1207 : : bool status;
1208 : :
1209 : 0 : status = early_init_dt_verify(params);
1210 : 0 : if (!status)
1211 : : return false;
1212 : :
1213 : 0 : early_init_dt_scan_nodes();
1214 : 0 : return true;
1215 : : }
1216 : :
1217 : : /**
1218 : : * unflatten_device_tree - create tree of device_nodes from flat blob
1219 : : *
1220 : : * unflattens the device-tree passed by the firmware, creating the
1221 : : * tree of struct device_node. It also fills the "name" and "type"
1222 : : * pointers of the nodes so the normal device-tree walking functions
1223 : : * can be used.
1224 : : */
1225 : 3 : void __init unflatten_device_tree(void)
1226 : : {
1227 : 3 : __unflatten_device_tree(initial_boot_params, NULL, &of_root,
1228 : : early_init_dt_alloc_memory_arch, false);
1229 : :
1230 : : /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
1231 : 3 : of_alias_scan(early_init_dt_alloc_memory_arch);
1232 : :
1233 : : unittest_unflatten_overlay_base();
1234 : 3 : }
1235 : :
1236 : : /**
1237 : : * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
1238 : : *
1239 : : * Copies and unflattens the device-tree passed by the firmware, creating the
1240 : : * tree of struct device_node. It also fills the "name" and "type"
1241 : : * pointers of the nodes so the normal device-tree walking functions
1242 : : * can be used. This should only be used when the FDT memory has not been
1243 : : * reserved such is the case when the FDT is built-in to the kernel init
1244 : : * section. If the FDT memory is reserved already then unflatten_device_tree
1245 : : * should be used instead.
1246 : : */
1247 : 0 : void __init unflatten_and_copy_device_tree(void)
1248 : : {
1249 : : int size;
1250 : : void *dt;
1251 : :
1252 : 0 : if (!initial_boot_params) {
1253 : 0 : pr_warn("No valid device tree found, continuing without\n");
1254 : 0 : return;
1255 : : }
1256 : :
1257 : 0 : size = fdt_totalsize(initial_boot_params);
1258 : 0 : dt = early_init_dt_alloc_memory_arch(size,
1259 : : roundup_pow_of_two(FDT_V17_SIZE));
1260 : :
1261 : 0 : if (dt) {
1262 : 0 : memcpy(dt, initial_boot_params, size);
1263 : 0 : initial_boot_params = dt;
1264 : : }
1265 : 0 : unflatten_device_tree();
1266 : : }
1267 : :
1268 : : #ifdef CONFIG_SYSFS
1269 : 0 : static ssize_t of_fdt_raw_read(struct file *filp, struct kobject *kobj,
1270 : : struct bin_attribute *bin_attr,
1271 : : char *buf, loff_t off, size_t count)
1272 : : {
1273 : 0 : memcpy(buf, initial_boot_params + off, count);
1274 : 0 : return count;
1275 : : }
1276 : :
1277 : 3 : static int __init of_fdt_raw_init(void)
1278 : : {
1279 : : static struct bin_attribute of_fdt_raw_attr =
1280 : : __BIN_ATTR(fdt, S_IRUSR, of_fdt_raw_read, NULL, 0);
1281 : :
1282 : 3 : if (!initial_boot_params)
1283 : : return 0;
1284 : :
1285 : 3 : if (of_fdt_crc32 != crc32_be(~0, initial_boot_params,
1286 : : fdt_totalsize(initial_boot_params))) {
1287 : 0 : pr_warn("not creating '/sys/firmware/fdt': CRC check failed\n");
1288 : 0 : return 0;
1289 : : }
1290 : 3 : of_fdt_raw_attr.size = fdt_totalsize(initial_boot_params);
1291 : 3 : return sysfs_create_bin_file(firmware_kobj, &of_fdt_raw_attr);
1292 : : }
1293 : : late_initcall(of_fdt_raw_init);
1294 : : #endif
1295 : :
1296 : : #endif /* CONFIG_OF_EARLY_FLATTREE */
|
