blob: 758b4f8b30b7d237c92b6a541f01db535d37101b [file] [log] [blame]
Grant Likelye169cfb2009-11-23 14:53:09 -07001/*
2 * Functions for working with the Flattened Device Tree data format
3 *
4 * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
5 * benh@kernel.crashing.org
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2 as published by the Free Software Foundation.
10 */
11
Grant Likely41f88002009-11-23 20:07:01 -070012#include <linux/kernel.h>
Grant Likelyf7b3a832009-11-24 03:26:58 -070013#include <linux/initrd.h>
Grant Likelya1727da2013-08-28 21:18:32 +010014#include <linux/memblock.h>
Stephen Neuendorfferfe140422010-11-18 15:55:02 -080015#include <linux/module.h>
Grant Likelye169cfb2009-11-23 14:53:09 -070016#include <linux/of.h>
17#include <linux/of_fdt.h>
Jeremy Kerr4ef7b372010-02-14 07:13:47 -070018#include <linux/string.h>
19#include <linux/errno.h>
Stephen Neuendorfferfe140422010-11-18 15:55:02 -080020#include <linux/slab.h>
Grant Likely51975db2010-02-01 21:34:14 -070021
Fabio Estevamc89810a2012-01-02 14:19:03 -020022#include <asm/setup.h> /* for COMMAND_LINE_SIZE */
Grant Likely86e03222009-12-10 23:42:21 -070023#ifdef CONFIG_PPC
24#include <asm/machdep.h>
25#endif /* CONFIG_PPC */
26
Jeremy Kerr4ef7b372010-02-14 07:13:47 -070027#include <asm/page.h>
28
Stephen Neuendorffer9706a362010-11-18 15:54:59 -080029char *of_fdt_get_string(struct boot_param_header *blob, u32 offset)
30{
31 return ((char *)blob) +
32 be32_to_cpu(blob->off_dt_strings) + offset;
33}
34
35/**
36 * of_fdt_get_property - Given a node in the given flat blob, return
37 * the property ptr
38 */
39void *of_fdt_get_property(struct boot_param_header *blob,
40 unsigned long node, const char *name,
41 unsigned long *size)
42{
43 unsigned long p = node;
44
45 do {
46 u32 tag = be32_to_cpup((__be32 *)p);
47 u32 sz, noff;
48 const char *nstr;
49
50 p += 4;
51 if (tag == OF_DT_NOP)
52 continue;
53 if (tag != OF_DT_PROP)
54 return NULL;
55
56 sz = be32_to_cpup((__be32 *)p);
57 noff = be32_to_cpup((__be32 *)(p + 4));
58 p += 8;
59 if (be32_to_cpu(blob->version) < 0x10)
60 p = ALIGN(p, sz >= 8 ? 8 : 4);
61
62 nstr = of_fdt_get_string(blob, noff);
63 if (nstr == NULL) {
64 pr_warning("Can't find property index name !\n");
65 return NULL;
66 }
67 if (strcmp(name, nstr) == 0) {
68 if (size)
69 *size = sz;
70 return (void *)p;
71 }
72 p += sz;
73 p = ALIGN(p, 4);
74 } while (1);
75}
76
77/**
78 * of_fdt_is_compatible - Return true if given node from the given blob has
79 * compat in its compatible list
80 * @blob: A device tree blob
81 * @node: node to test
82 * @compat: compatible string to compare with compatible list.
Grant Likelya4f740c2010-10-30 11:49:09 -040083 *
84 * On match, returns a non-zero value with smaller values returned for more
85 * specific compatible values.
Stephen Neuendorffer9706a362010-11-18 15:54:59 -080086 */
87int of_fdt_is_compatible(struct boot_param_header *blob,
88 unsigned long node, const char *compat)
89{
90 const char *cp;
Grant Likelya4f740c2010-10-30 11:49:09 -040091 unsigned long cplen, l, score = 0;
Stephen Neuendorffer9706a362010-11-18 15:54:59 -080092
93 cp = of_fdt_get_property(blob, node, "compatible", &cplen);
94 if (cp == NULL)
95 return 0;
96 while (cplen > 0) {
Grant Likelya4f740c2010-10-30 11:49:09 -040097 score++;
Stephen Neuendorffer9706a362010-11-18 15:54:59 -080098 if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
Grant Likelya4f740c2010-10-30 11:49:09 -040099 return score;
Stephen Neuendorffer9706a362010-11-18 15:54:59 -0800100 l = strlen(cp) + 1;
101 cp += l;
102 cplen -= l;
103 }
104
105 return 0;
106}
107
Grant Likelya4f740c2010-10-30 11:49:09 -0400108/**
109 * of_fdt_match - Return true if node matches a list of compatible values
110 */
111int of_fdt_match(struct boot_param_header *blob, unsigned long node,
Uwe Kleine-König7b482c82011-12-20 22:56:45 +0100112 const char *const *compat)
Grant Likelya4f740c2010-10-30 11:49:09 -0400113{
114 unsigned int tmp, score = 0;
115
116 if (!compat)
117 return 0;
118
119 while (*compat) {
120 tmp = of_fdt_is_compatible(blob, node, *compat);
121 if (tmp && (score == 0 || (tmp < score)))
122 score = tmp;
123 compat++;
124 }
125
126 return score;
127}
128
Grant Likely44856812013-08-29 13:30:35 +0100129static void *unflatten_dt_alloc(void **mem, unsigned long size,
Grant Likelybbd33932009-11-23 20:07:00 -0700130 unsigned long align)
131{
132 void *res;
133
Grant Likely44856812013-08-29 13:30:35 +0100134 *mem = PTR_ALIGN(*mem, align);
135 res = *mem;
Grant Likelybbd33932009-11-23 20:07:00 -0700136 *mem += size;
137
138 return res;
139}
140
141/**
142 * unflatten_dt_node - Alloc and populate a device_node from the flat tree
Stephen Neuendorffera40d6c42010-11-18 15:55:00 -0800143 * @blob: The parent device tree blob
Andres Salomona7006c92011-03-17 17:32:35 -0700144 * @mem: Memory chunk to use for allocating device nodes and properties
Grant Likelybbd33932009-11-23 20:07:00 -0700145 * @p: pointer to node in flat tree
146 * @dad: Parent struct device_node
147 * @allnextpp: pointer to ->allnext from last allocated device_node
148 * @fpsize: Size of the node path up at the current depth.
149 */
Grant Likely44856812013-08-29 13:30:35 +0100150static void * unflatten_dt_node(struct boot_param_header *blob,
151 void *mem,
152 void **p,
Stephen Neuendorffera40d6c42010-11-18 15:55:00 -0800153 struct device_node *dad,
154 struct device_node ***allnextpp,
155 unsigned long fpsize)
Grant Likelybbd33932009-11-23 20:07:00 -0700156{
157 struct device_node *np;
158 struct property *pp, **prev_pp = NULL;
159 char *pathp;
160 u32 tag;
161 unsigned int l, allocl;
162 int has_name = 0;
163 int new_format = 0;
164
Grant Likely44856812013-08-29 13:30:35 +0100165 tag = be32_to_cpup(*p);
Grant Likelybbd33932009-11-23 20:07:00 -0700166 if (tag != OF_DT_BEGIN_NODE) {
167 pr_err("Weird tag at start of node: %x\n", tag);
168 return mem;
169 }
170 *p += 4;
Grant Likely44856812013-08-29 13:30:35 +0100171 pathp = *p;
Grant Likelybbd33932009-11-23 20:07:00 -0700172 l = allocl = strlen(pathp) + 1;
Grant Likely44856812013-08-29 13:30:35 +0100173 *p = PTR_ALIGN(*p + l, 4);
Grant Likelybbd33932009-11-23 20:07:00 -0700174
175 /* version 0x10 has a more compact unit name here instead of the full
176 * path. we accumulate the full path size using "fpsize", we'll rebuild
177 * it later. We detect this because the first character of the name is
178 * not '/'.
179 */
180 if ((*pathp) != '/') {
181 new_format = 1;
182 if (fpsize == 0) {
183 /* root node: special case. fpsize accounts for path
184 * plus terminating zero. root node only has '/', so
185 * fpsize should be 2, but we want to avoid the first
186 * level nodes to have two '/' so we use fpsize 1 here
187 */
188 fpsize = 1;
189 allocl = 2;
Catalin Marinas0fca5de2012-11-16 15:14:38 +0000190 l = 1;
191 *pathp = '\0';
Grant Likelybbd33932009-11-23 20:07:00 -0700192 } else {
193 /* account for '/' and path size minus terminal 0
194 * already in 'l'
195 */
196 fpsize += l;
197 allocl = fpsize;
198 }
199 }
200
201 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
202 __alignof__(struct device_node));
203 if (allnextpp) {
Grant Likelyc22618a2012-11-14 22:37:12 +0000204 char *fn;
Grant Likelyc22618a2012-11-14 22:37:12 +0000205 np->full_name = fn = ((char *)np) + sizeof(*np);
Grant Likelybbd33932009-11-23 20:07:00 -0700206 if (new_format) {
Grant Likelybbd33932009-11-23 20:07:00 -0700207 /* rebuild full path for new format */
208 if (dad && dad->parent) {
209 strcpy(fn, dad->full_name);
210#ifdef DEBUG
211 if ((strlen(fn) + l + 1) != allocl) {
212 pr_debug("%s: p: %d, l: %d, a: %d\n",
213 pathp, (int)strlen(fn),
214 l, allocl);
215 }
216#endif
217 fn += strlen(fn);
218 }
219 *(fn++) = '/';
Grant Likelyc22618a2012-11-14 22:37:12 +0000220 }
221 memcpy(fn, pathp, l);
222
Grant Likelybbd33932009-11-23 20:07:00 -0700223 prev_pp = &np->properties;
224 **allnextpp = np;
225 *allnextpp = &np->allnext;
226 if (dad != NULL) {
227 np->parent = dad;
228 /* we temporarily use the next field as `last_child'*/
229 if (dad->next == NULL)
230 dad->child = np;
231 else
232 dad->next->sibling = np;
233 dad->next = np;
234 }
235 kref_init(&np->kref);
236 }
Andres Salomona7006c92011-03-17 17:32:35 -0700237 /* process properties */
Grant Likelybbd33932009-11-23 20:07:00 -0700238 while (1) {
239 u32 sz, noff;
240 char *pname;
241
Grant Likely44856812013-08-29 13:30:35 +0100242 tag = be32_to_cpup(*p);
Grant Likelybbd33932009-11-23 20:07:00 -0700243 if (tag == OF_DT_NOP) {
244 *p += 4;
245 continue;
246 }
247 if (tag != OF_DT_PROP)
248 break;
249 *p += 4;
Grant Likely44856812013-08-29 13:30:35 +0100250 sz = be32_to_cpup(*p);
251 noff = be32_to_cpup(*p + 4);
Grant Likelybbd33932009-11-23 20:07:00 -0700252 *p += 8;
Stephen Neuendorffera40d6c42010-11-18 15:55:00 -0800253 if (be32_to_cpu(blob->version) < 0x10)
Grant Likely44856812013-08-29 13:30:35 +0100254 *p = PTR_ALIGN(*p, sz >= 8 ? 8 : 4);
Grant Likelybbd33932009-11-23 20:07:00 -0700255
Stephen Neuendorffera40d6c42010-11-18 15:55:00 -0800256 pname = of_fdt_get_string(blob, noff);
Grant Likelybbd33932009-11-23 20:07:00 -0700257 if (pname == NULL) {
258 pr_info("Can't find property name in list !\n");
259 break;
260 }
261 if (strcmp(pname, "name") == 0)
262 has_name = 1;
263 l = strlen(pname) + 1;
264 pp = unflatten_dt_alloc(&mem, sizeof(struct property),
265 __alignof__(struct property));
266 if (allnextpp) {
David Gibson04b954a2010-02-01 21:34:15 -0700267 /* We accept flattened tree phandles either in
268 * ePAPR-style "phandle" properties, or the
269 * legacy "linux,phandle" properties. If both
270 * appear and have different values, things
271 * will get weird. Don't do that. */
272 if ((strcmp(pname, "phandle") == 0) ||
273 (strcmp(pname, "linux,phandle") == 0)) {
Grant Likely6016a362010-01-28 14:06:53 -0700274 if (np->phandle == 0)
Grant Likely9a6b2e52010-07-23 01:48:25 -0600275 np->phandle = be32_to_cpup((__be32*)*p);
Grant Likelybbd33932009-11-23 20:07:00 -0700276 }
David Gibson04b954a2010-02-01 21:34:15 -0700277 /* And we process the "ibm,phandle" property
278 * used in pSeries dynamic device tree
279 * stuff */
Grant Likelybbd33932009-11-23 20:07:00 -0700280 if (strcmp(pname, "ibm,phandle") == 0)
Grant Likely9a6b2e52010-07-23 01:48:25 -0600281 np->phandle = be32_to_cpup((__be32 *)*p);
Grant Likelybbd33932009-11-23 20:07:00 -0700282 pp->name = pname;
283 pp->length = sz;
Grant Likely44856812013-08-29 13:30:35 +0100284 pp->value = *p;
Grant Likelybbd33932009-11-23 20:07:00 -0700285 *prev_pp = pp;
286 prev_pp = &pp->next;
287 }
Grant Likely44856812013-08-29 13:30:35 +0100288 *p = PTR_ALIGN((*p) + sz, 4);
Grant Likelybbd33932009-11-23 20:07:00 -0700289 }
290 /* with version 0x10 we may not have the name property, recreate
291 * it here from the unit name if absent
292 */
293 if (!has_name) {
294 char *p1 = pathp, *ps = pathp, *pa = NULL;
295 int sz;
296
297 while (*p1) {
298 if ((*p1) == '@')
299 pa = p1;
300 if ((*p1) == '/')
301 ps = p1 + 1;
302 p1++;
303 }
304 if (pa < ps)
305 pa = p1;
306 sz = (pa - ps) + 1;
307 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
308 __alignof__(struct property));
309 if (allnextpp) {
310 pp->name = "name";
311 pp->length = sz;
312 pp->value = pp + 1;
313 *prev_pp = pp;
314 prev_pp = &pp->next;
315 memcpy(pp->value, ps, sz - 1);
316 ((char *)pp->value)[sz - 1] = 0;
317 pr_debug("fixed up name for %s -> %s\n", pathp,
318 (char *)pp->value);
319 }
320 }
321 if (allnextpp) {
322 *prev_pp = NULL;
323 np->name = of_get_property(np, "name", NULL);
324 np->type = of_get_property(np, "device_type", NULL);
325
326 if (!np->name)
327 np->name = "<NULL>";
328 if (!np->type)
329 np->type = "<NULL>";
330 }
Jason Gunthorpe7f809e12010-03-26 22:09:56 -0600331 while (tag == OF_DT_BEGIN_NODE || tag == OF_DT_NOP) {
332 if (tag == OF_DT_NOP)
333 *p += 4;
334 else
Stephen Neuendorffera40d6c42010-11-18 15:55:00 -0800335 mem = unflatten_dt_node(blob, mem, p, np, allnextpp,
336 fpsize);
Grant Likely44856812013-08-29 13:30:35 +0100337 tag = be32_to_cpup(*p);
Grant Likelybbd33932009-11-23 20:07:00 -0700338 }
339 if (tag != OF_DT_END_NODE) {
340 pr_err("Weird tag at end of node: %x\n", tag);
341 return mem;
342 }
343 *p += 4;
344 return mem;
345}
Grant Likely41f88002009-11-23 20:07:01 -0700346
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800347/**
348 * __unflatten_device_tree - create tree of device_nodes from flat blob
349 *
350 * unflattens a device-tree, creating the
351 * tree of struct device_node. It also fills the "name" and "type"
352 * pointers of the nodes so the normal device-tree walking functions
353 * can be used.
354 * @blob: The blob to expand
355 * @mynodes: The device_node tree created by the call
356 * @dt_alloc: An allocator that provides a virtual address to memory
357 * for the resulting tree
358 */
Andres Salomona7006c92011-03-17 17:32:35 -0700359static void __unflatten_device_tree(struct boot_param_header *blob,
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800360 struct device_node **mynodes,
361 void * (*dt_alloc)(u64 size, u64 align))
362{
Grant Likely44856812013-08-29 13:30:35 +0100363 unsigned long size;
364 void *start, *mem;
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800365 struct device_node **allnextp = mynodes;
366
367 pr_debug(" -> unflatten_device_tree()\n");
368
369 if (!blob) {
370 pr_debug("No device tree pointer\n");
371 return;
372 }
373
374 pr_debug("Unflattening device tree:\n");
375 pr_debug("magic: %08x\n", be32_to_cpu(blob->magic));
376 pr_debug("size: %08x\n", be32_to_cpu(blob->totalsize));
377 pr_debug("version: %08x\n", be32_to_cpu(blob->version));
378
379 if (be32_to_cpu(blob->magic) != OF_DT_HEADER) {
380 pr_err("Invalid device tree blob header\n");
381 return;
382 }
383
384 /* First pass, scan for size */
Grant Likely44856812013-08-29 13:30:35 +0100385 start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
386 size = (unsigned long)unflatten_dt_node(blob, 0, &start, NULL, NULL, 0);
387 size = ALIGN(size, 4);
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800388
389 pr_debug(" size is %lx, allocating...\n", size);
390
391 /* Allocate memory for the expanded device tree */
Grant Likely44856812013-08-29 13:30:35 +0100392 mem = dt_alloc(size + 4, __alignof__(struct device_node));
393 memset(mem, 0, size);
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800394
Grant Likely44856812013-08-29 13:30:35 +0100395 *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
Wladislav Wiebe9e401272013-08-12 13:06:53 +0200396
Grant Likely44856812013-08-29 13:30:35 +0100397 pr_debug(" unflattening %p...\n", mem);
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800398
399 /* Second pass, do actual unflattening */
Grant Likely44856812013-08-29 13:30:35 +0100400 start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800401 unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0);
Grant Likely44856812013-08-29 13:30:35 +0100402 if (be32_to_cpup(start) != OF_DT_END)
403 pr_warning("Weird tag at end of tree: %08x\n", be32_to_cpup(start));
404 if (be32_to_cpup(mem + size) != 0xdeadbeef)
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800405 pr_warning("End of tree marker overwritten: %08x\n",
Grant Likely44856812013-08-29 13:30:35 +0100406 be32_to_cpup(mem + size));
Stephen Neuendorfferfe140422010-11-18 15:55:02 -0800407 *allnextp = NULL;
408
409 pr_debug(" <- unflatten_device_tree()\n");
410}
411
412static void *kernel_tree_alloc(u64 size, u64 align)
413{
414 return kzalloc(size, GFP_KERNEL);
415}
416
417/**
418 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
419 *
420 * unflattens the device-tree passed by the firmware, creating the
421 * tree of struct device_node. It also fills the "name" and "type"
422 * pointers of the nodes so the normal device-tree walking functions
423 * can be used.
424 */
425void of_fdt_unflatten_tree(unsigned long *blob,
426 struct device_node **mynodes)
427{
428 struct boot_param_header *device_tree =
429 (struct boot_param_header *)blob;
430 __unflatten_device_tree(device_tree, mynodes, &kernel_tree_alloc);
431}
432EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree);
433
Stephen Neuendorffer57d00ec2010-11-18 15:55:01 -0800434/* Everything below here references initial_boot_params directly. */
435int __initdata dt_root_addr_cells;
436int __initdata dt_root_size_cells;
437
438struct boot_param_header *initial_boot_params;
439
440#ifdef CONFIG_OF_EARLY_FLATTREE
441
442/**
443 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
444 * @it: callback function
445 * @data: context data pointer
446 *
447 * This function is used to scan the flattened device-tree, it is
448 * used to extract the memory information at boot before we can
449 * unflatten the tree
450 */
451int __init of_scan_flat_dt(int (*it)(unsigned long node,
452 const char *uname, int depth,
453 void *data),
454 void *data)
455{
456 unsigned long p = ((unsigned long)initial_boot_params) +
457 be32_to_cpu(initial_boot_params->off_dt_struct);
458 int rc = 0;
459 int depth = -1;
460
461 do {
462 u32 tag = be32_to_cpup((__be32 *)p);
Fabio Estevame55b0822012-11-12 18:30:49 -0200463 const char *pathp;
Stephen Neuendorffer57d00ec2010-11-18 15:55:01 -0800464
465 p += 4;
466 if (tag == OF_DT_END_NODE) {
467 depth--;
468 continue;
469 }
470 if (tag == OF_DT_NOP)
471 continue;
472 if (tag == OF_DT_END)
473 break;
474 if (tag == OF_DT_PROP) {
475 u32 sz = be32_to_cpup((__be32 *)p);
476 p += 8;
477 if (be32_to_cpu(initial_boot_params->version) < 0x10)
478 p = ALIGN(p, sz >= 8 ? 8 : 4);
479 p += sz;
480 p = ALIGN(p, 4);
481 continue;
482 }
483 if (tag != OF_DT_BEGIN_NODE) {
484 pr_err("Invalid tag %x in flat device tree!\n", tag);
485 return -EINVAL;
486 }
487 depth++;
488 pathp = (char *)p;
489 p = ALIGN(p + strlen(pathp) + 1, 4);
Andy Shevchenko375da3a2012-12-17 16:01:28 -0800490 if (*pathp == '/')
491 pathp = kbasename(pathp);
Stephen Neuendorffer57d00ec2010-11-18 15:55:01 -0800492 rc = it(p, pathp, depth, data);
493 if (rc != 0)
494 break;
495 } while (1);
496
497 return rc;
498}
499
500/**
501 * of_get_flat_dt_root - find the root node in the flat blob
502 */
503unsigned long __init of_get_flat_dt_root(void)
504{
505 unsigned long p = ((unsigned long)initial_boot_params) +
506 be32_to_cpu(initial_boot_params->off_dt_struct);
507
508 while (be32_to_cpup((__be32 *)p) == OF_DT_NOP)
509 p += 4;
510 BUG_ON(be32_to_cpup((__be32 *)p) != OF_DT_BEGIN_NODE);
511 p += 4;
512 return ALIGN(p + strlen((char *)p) + 1, 4);
513}
514
515/**
516 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
517 *
518 * This function can be used within scan_flattened_dt callback to get
519 * access to properties
520 */
521void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
522 unsigned long *size)
523{
524 return of_fdt_get_property(initial_boot_params, node, name, size);
525}
526
527/**
528 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
529 * @node: node to test
530 * @compat: compatible string to compare with compatible list.
531 */
532int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
533{
534 return of_fdt_is_compatible(initial_boot_params, node, compat);
535}
536
Grant Likelya4f740c2010-10-30 11:49:09 -0400537/**
538 * of_flat_dt_match - Return true if node matches a list of compatible values
539 */
Uwe Kleine-König7b482c82011-12-20 22:56:45 +0100540int __init of_flat_dt_match(unsigned long node, const char *const *compat)
Grant Likelya4f740c2010-10-30 11:49:09 -0400541{
542 return of_fdt_match(initial_boot_params, node, compat);
543}
544
Marek Szyprowski57d74bc2013-08-26 14:41:56 +0200545struct fdt_scan_status {
546 const char *name;
547 int namelen;
548 int depth;
549 int found;
550 int (*iterator)(unsigned long node, const char *uname, int depth, void *data);
551 void *data;
552};
553
554/**
555 * fdt_scan_node_by_path - iterator for of_scan_flat_dt_by_path function
556 */
557static int __init fdt_scan_node_by_path(unsigned long node, const char *uname,
558 int depth, void *data)
559{
560 struct fdt_scan_status *st = data;
561
562 /*
563 * if scan at the requested fdt node has been completed,
564 * return -ENXIO to abort further scanning
565 */
566 if (depth <= st->depth)
567 return -ENXIO;
568
569 /* requested fdt node has been found, so call iterator function */
570 if (st->found)
571 return st->iterator(node, uname, depth, st->data);
572
573 /* check if scanning automata is entering next level of fdt nodes */
574 if (depth == st->depth + 1 &&
575 strncmp(st->name, uname, st->namelen) == 0 &&
576 uname[st->namelen] == 0) {
577 st->depth += 1;
578 if (st->name[st->namelen] == 0) {
579 st->found = 1;
580 } else {
581 const char *next = st->name + st->namelen + 1;
582 st->name = next;
583 st->namelen = strcspn(next, "/");
584 }
585 return 0;
586 }
587
588 /* scan next fdt node */
589 return 0;
590}
591
592/**
593 * of_scan_flat_dt_by_path - scan flattened tree blob and call callback on each
594 * child of the given path.
595 * @path: path to start searching for children
596 * @it: callback function
597 * @data: context data pointer
598 *
599 * This function is used to scan the flattened device-tree starting from the
600 * node given by path. It is used to extract information (like reserved
601 * memory), which is required on ealy boot before we can unflatten the tree.
602 */
603int __init of_scan_flat_dt_by_path(const char *path,
604 int (*it)(unsigned long node, const char *name, int depth, void *data),
605 void *data)
606{
607 struct fdt_scan_status st = {path, 0, -1, 0, it, data};
608 int ret = 0;
609
610 if (initial_boot_params)
611 ret = of_scan_flat_dt(fdt_scan_node_by_path, &st);
612
613 if (!st.found)
614 return -ENOENT;
615 else if (ret == -ENXIO) /* scan has been completed */
616 return 0;
617 else
618 return ret;
619}
620
Rob Herring6a903a22013-08-27 21:41:56 -0500621const char * __init of_flat_dt_get_machine_name(void)
622{
623 const char *name;
624 unsigned long dt_root = of_get_flat_dt_root();
625
626 name = of_get_flat_dt_prop(dt_root, "model", NULL);
627 if (!name)
628 name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
629 return name;
630}
631
632/**
633 * of_flat_dt_match_machine - Iterate match tables to find matching machine.
634 *
635 * @default_match: A machine specific ptr to return in case of no match.
636 * @get_next_compat: callback function to return next compatible match table.
637 *
638 * Iterate through machine match tables to find the best match for the machine
639 * compatible string in the FDT.
640 */
641const void * __init of_flat_dt_match_machine(const void *default_match,
642 const void * (*get_next_compat)(const char * const**))
643{
644 const void *data = NULL;
645 const void *best_data = default_match;
646 const char *const *compat;
647 unsigned long dt_root;
648 unsigned int best_score = ~1, score = 0;
649
650 dt_root = of_get_flat_dt_root();
651 while ((data = get_next_compat(&compat))) {
652 score = of_flat_dt_match(dt_root, compat);
653 if (score > 0 && score < best_score) {
654 best_data = data;
655 best_score = score;
656 }
657 }
658 if (!best_data) {
659 const char *prop;
660 long size;
661
662 pr_err("\n unrecognized device tree list:\n[ ");
663
664 prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
665 if (prop) {
666 while (size > 0) {
667 printk("'%s' ", prop);
668 size -= strlen(prop) + 1;
669 prop += strlen(prop) + 1;
670 }
671 }
672 printk("]\n\n");
673 return NULL;
674 }
675
676 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
677
678 return best_data;
679}
680
Grant Likelyf7b3a832009-11-24 03:26:58 -0700681#ifdef CONFIG_BLK_DEV_INITRD
682/**
683 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
684 * @node: reference to node containing initrd location ('chosen')
685 */
Rob Herring29eb45a2013-08-30 17:06:53 -0500686static void __init early_init_dt_check_for_initrd(unsigned long node)
Grant Likelyf7b3a832009-11-24 03:26:58 -0700687{
Santosh Shilimkar374d5c92013-07-01 14:20:35 -0400688 u64 start, end;
689 unsigned long len;
Jeremy Kerr33714882010-01-30 01:45:26 -0700690 __be32 *prop;
Grant Likelyf7b3a832009-11-24 03:26:58 -0700691
692 pr_debug("Looking for initrd properties... ");
693
694 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
Jeremy Kerr1406bc22010-01-30 01:31:21 -0700695 if (!prop)
696 return;
Santosh Shilimkar374d5c92013-07-01 14:20:35 -0400697 start = of_read_number(prop, len/4);
Grant Likelyf7b3a832009-11-24 03:26:58 -0700698
Jeremy Kerr1406bc22010-01-30 01:31:21 -0700699 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
700 if (!prop)
701 return;
Santosh Shilimkar374d5c92013-07-01 14:20:35 -0400702 end = of_read_number(prop, len/4);
Grant Likelyf7b3a832009-11-24 03:26:58 -0700703
Rob Herring29eb45a2013-08-30 17:06:53 -0500704 initrd_start = (unsigned long)__va(start);
705 initrd_end = (unsigned long)__va(end);
706 initrd_below_start_ok = 1;
707
Santosh Shilimkar374d5c92013-07-01 14:20:35 -0400708 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
709 (unsigned long long)start, (unsigned long long)end);
Grant Likelyf7b3a832009-11-24 03:26:58 -0700710}
711#else
Rob Herring29eb45a2013-08-30 17:06:53 -0500712static inline void early_init_dt_check_for_initrd(unsigned long node)
Grant Likelyf7b3a832009-11-24 03:26:58 -0700713{
714}
715#endif /* CONFIG_BLK_DEV_INITRD */
716
Grant Likely41f88002009-11-23 20:07:01 -0700717/**
Grant Likelyf00abd92009-11-24 03:27:10 -0700718 * early_init_dt_scan_root - fetch the top level address and size cells
719 */
720int __init early_init_dt_scan_root(unsigned long node, const char *uname,
721 int depth, void *data)
722{
Jeremy Kerr33714882010-01-30 01:45:26 -0700723 __be32 *prop;
Grant Likelyf00abd92009-11-24 03:27:10 -0700724
725 if (depth != 0)
726 return 0;
727
Jeremy Kerr33714882010-01-30 01:45:26 -0700728 dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
729 dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
730
Grant Likelyf00abd92009-11-24 03:27:10 -0700731 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
Jeremy Kerr33714882010-01-30 01:45:26 -0700732 if (prop)
733 dt_root_size_cells = be32_to_cpup(prop);
Grant Likelyf00abd92009-11-24 03:27:10 -0700734 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
735
736 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
Jeremy Kerr33714882010-01-30 01:45:26 -0700737 if (prop)
738 dt_root_addr_cells = be32_to_cpup(prop);
Grant Likelyf00abd92009-11-24 03:27:10 -0700739 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
740
741 /* break now */
742 return 1;
743}
744
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700745u64 __init dt_mem_next_cell(int s, __be32 **cellp)
Grant Likely83f7a062009-11-24 03:37:56 -0700746{
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700747 __be32 *p = *cellp;
Grant Likely83f7a062009-11-24 03:37:56 -0700748
749 *cellp = p + s;
750 return of_read_number(p, s);
751}
752
Grant Likely51975db2010-02-01 21:34:14 -0700753/**
754 * early_init_dt_scan_memory - Look for an parse memory nodes
755 */
756int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
757 int depth, void *data)
758{
759 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
760 __be32 *reg, *endp;
761 unsigned long l;
762
763 /* We are scanning "memory" nodes only */
764 if (type == NULL) {
765 /*
766 * The longtrail doesn't have a device_type on the
767 * /memory node, so look for the node called /memory@0.
768 */
769 if (depth != 1 || strcmp(uname, "memory@0") != 0)
770 return 0;
771 } else if (strcmp(type, "memory") != 0)
772 return 0;
773
774 reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
775 if (reg == NULL)
776 reg = of_get_flat_dt_prop(node, "reg", &l);
777 if (reg == NULL)
778 return 0;
779
780 endp = reg + (l / sizeof(__be32));
781
782 pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
783 uname, l, reg[0], reg[1], reg[2], reg[3]);
784
785 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
786 u64 base, size;
787
788 base = dt_mem_next_cell(dt_root_addr_cells, &reg);
789 size = dt_mem_next_cell(dt_root_size_cells, &reg);
790
791 if (size == 0)
792 continue;
793 pr_debug(" - %llx , %llx\n", (unsigned long long)base,
794 (unsigned long long)size);
795
796 early_init_dt_add_memory_arch(base, size);
797 }
798
799 return 0;
800}
801
Grant Likely86e03222009-12-10 23:42:21 -0700802int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
803 int depth, void *data)
804{
805 unsigned long l;
806 char *p;
807
808 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
809
Grant Likely85f60ae2011-04-29 00:18:16 -0600810 if (depth != 1 || !data ||
Grant Likely86e03222009-12-10 23:42:21 -0700811 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
812 return 0;
813
814 early_init_dt_check_for_initrd(node);
815
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300816 /* Retrieve command line */
Grant Likely86e03222009-12-10 23:42:21 -0700817 p = of_get_flat_dt_prop(node, "bootargs", &l);
818 if (p != NULL && l > 0)
Grant Likely85f60ae2011-04-29 00:18:16 -0600819 strlcpy(data, p, min((int)l, COMMAND_LINE_SIZE));
Grant Likely86e03222009-12-10 23:42:21 -0700820
Benjamin Herrenschmidt78b782c2011-09-19 18:50:15 +0000821 /*
822 * CONFIG_CMDLINE is meant to be a default in case nothing else
823 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
824 * is set in which case we override whatever was found earlier.
825 */
Grant Likely86e03222009-12-10 23:42:21 -0700826#ifdef CONFIG_CMDLINE
827#ifndef CONFIG_CMDLINE_FORCE
Benjamin Herrenschmidt78b782c2011-09-19 18:50:15 +0000828 if (!((char *)data)[0])
Grant Likely86e03222009-12-10 23:42:21 -0700829#endif
Grant Likely85f60ae2011-04-29 00:18:16 -0600830 strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
Grant Likely86e03222009-12-10 23:42:21 -0700831#endif /* CONFIG_CMDLINE */
832
Grant Likely85f60ae2011-04-29 00:18:16 -0600833 pr_debug("Command line is: %s\n", (char*)data);
Grant Likely86e03222009-12-10 23:42:21 -0700834
835 /* break now */
836 return 1;
837}
838
Grant Likelya1727da2013-08-28 21:18:32 +0100839#ifdef CONFIG_HAVE_MEMBLOCK
Rob Herring068f6312013-09-24 22:20:01 -0500840void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
841{
842 const u64 phys_offset = __pa(PAGE_OFFSET);
843 base &= PAGE_MASK;
844 size &= PAGE_MASK;
845 if (base + size < phys_offset) {
846 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
847 base, base + size);
848 return;
849 }
850 if (base < phys_offset) {
851 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
852 base, phys_offset);
853 size -= phys_offset - base;
854 base = phys_offset;
855 }
856 memblock_add(base, size);
857}
858
Grant Likelya1727da2013-08-28 21:18:32 +0100859/*
860 * called from unflatten_device_tree() to bootstrap devicetree itself
861 * Architectures can override this definition if memblock isn't used
862 */
863void * __init __weak early_init_dt_alloc_memory_arch(u64 size, u64 align)
864{
865 return __va(memblock_alloc(size, align));
866}
867#endif
868
Rob Herring0288ffcb2013-08-26 09:47:40 -0500869bool __init early_init_dt_scan(void *params)
870{
871 if (!params)
872 return false;
873
874 /* Setup flat device-tree pointer */
875 initial_boot_params = params;
876
877 /* check device tree validity */
878 if (be32_to_cpu(initial_boot_params->magic) != OF_DT_HEADER) {
879 initial_boot_params = NULL;
880 return false;
881 }
882
883 /* Retrieve various information from the /chosen node */
884 of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
885
886 /* Initialize {size,address}-cells info */
887 of_scan_flat_dt(early_init_dt_scan_root, NULL);
888
889 /* Setup memory, calling early_init_dt_add_memory_arch */
890 of_scan_flat_dt(early_init_dt_scan_memory, NULL);
891
892 return true;
893}
894
Grant Likelyf00abd92009-11-24 03:27:10 -0700895/**
Grant Likely41f88002009-11-23 20:07:01 -0700896 * unflatten_device_tree - create tree of device_nodes from flat blob
897 *
898 * unflattens the device-tree passed by the firmware, creating the
899 * tree of struct device_node. It also fills the "name" and "type"
900 * pointers of the nodes so the normal device-tree walking functions
901 * can be used.
902 */
903void __init unflatten_device_tree(void)
904{
Randy Dunlap465aac62012-11-30 10:01:51 +0000905 __unflatten_device_tree(initial_boot_params, &of_allnodes,
Grant Likely672c5442011-01-13 15:36:09 -0700906 early_init_dt_alloc_memory_arch);
Grant Likely41f88002009-11-23 20:07:01 -0700907
Robert P. J. Day4c7d6362013-05-30 05:38:08 -0400908 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
Shawn Guo611cad72011-08-15 15:28:14 +0800909 of_alias_scan(early_init_dt_alloc_memory_arch);
Grant Likely41f88002009-11-23 20:07:01 -0700910}
Stephen Neuendorffere6ce1322010-11-18 15:54:56 -0800911
Rob Herringa8bf7522013-08-26 11:22:45 -0500912/**
913 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
914 *
915 * Copies and unflattens the device-tree passed by the firmware, creating the
916 * tree of struct device_node. It also fills the "name" and "type"
917 * pointers of the nodes so the normal device-tree walking functions
918 * can be used. This should only be used when the FDT memory has not been
919 * reserved such is the case when the FDT is built-in to the kernel init
920 * section. If the FDT memory is reserved already then unflatten_device_tree
921 * should be used instead.
922 */
923void __init unflatten_and_copy_device_tree(void)
924{
James Hogan6f041e92013-11-21 13:44:14 +0000925 int size;
926 void *dt;
927
928 if (!initial_boot_params) {
929 pr_warn("No valid device tree found, continuing without\n");
930 return;
931 }
932
933 size = __be32_to_cpu(initial_boot_params->totalsize);
934 dt = early_init_dt_alloc_memory_arch(size,
Rob Herringa8bf7522013-08-26 11:22:45 -0500935 __alignof__(struct boot_param_header));
936
937 if (dt) {
938 memcpy(dt, initial_boot_params, size);
939 initial_boot_params = dt;
940 }
941 unflatten_device_tree();
942}
943
Stephen Neuendorffere6ce1322010-11-18 15:54:56 -0800944#endif /* CONFIG_OF_EARLY_FLATTREE */