xref: /openbmc/u-boot/lib/libfdt/fdt_ro.c (revision cbd2fba1)
1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-2-Clause
2 /*
3  * libfdt - Flat Device Tree manipulation
4  * Copyright (C) 2006 David Gibson, IBM Corporation.
5  */
6 #include <linux/libfdt_env.h>
7 
8 #ifndef USE_HOSTCC
9 #include <fdt.h>
10 #include <linux/libfdt.h>
11 #else
12 #include "fdt_host.h"
13 #endif
14 
15 #include "libfdt_internal.h"
16 
17 static int _fdt_nodename_eq(const void *fdt, int offset,
18 			    const char *s, int len)
19 {
20 	const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
21 
22 	if (!p)
23 		/* short match */
24 		return 0;
25 
26 	if (memcmp(p, s, len) != 0)
27 		return 0;
28 
29 	if (p[len] == '\0')
30 		return 1;
31 	else if (!memchr(s, '@', len) && (p[len] == '@'))
32 		return 1;
33 	else
34 		return 0;
35 }
36 
37 const char *fdt_string(const void *fdt, int stroffset)
38 {
39 	return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
40 }
41 
42 static int _fdt_string_eq(const void *fdt, int stroffset,
43 			  const char *s, int len)
44 {
45 	const char *p = fdt_string(fdt, stroffset);
46 
47 	return (strnlen(p, len + 1) == len) && (memcmp(p, s, len) == 0);
48 }
49 
50 uint32_t fdt_get_max_phandle(const void *fdt)
51 {
52 	uint32_t max_phandle = 0;
53 	int offset;
54 
55 	for (offset = fdt_next_node(fdt, -1, NULL);;
56 	     offset = fdt_next_node(fdt, offset, NULL)) {
57 		uint32_t phandle;
58 
59 		if (offset == -FDT_ERR_NOTFOUND)
60 			return max_phandle;
61 
62 		if (offset < 0)
63 			return (uint32_t)-1;
64 
65 		phandle = fdt_get_phandle(fdt, offset);
66 		if (phandle == (uint32_t)-1)
67 			continue;
68 
69 		if (phandle > max_phandle)
70 			max_phandle = phandle;
71 	}
72 
73 	return 0;
74 }
75 
76 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
77 {
78 	FDT_CHECK_HEADER(fdt);
79 	*address = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->address);
80 	*size = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->size);
81 	return 0;
82 }
83 
84 int fdt_num_mem_rsv(const void *fdt)
85 {
86 	int i = 0;
87 
88 	while (fdt64_to_cpu(fdt_mem_rsv_(fdt, i)->size) != 0)
89 		i++;
90 	return i;
91 }
92 
93 static int _nextprop(const void *fdt, int offset)
94 {
95 	uint32_t tag;
96 	int nextoffset;
97 
98 	do {
99 		tag = fdt_next_tag(fdt, offset, &nextoffset);
100 
101 		switch (tag) {
102 		case FDT_END:
103 			if (nextoffset >= 0)
104 				return -FDT_ERR_BADSTRUCTURE;
105 			else
106 				return nextoffset;
107 
108 		case FDT_PROP:
109 			return offset;
110 		}
111 		offset = nextoffset;
112 	} while (tag == FDT_NOP);
113 
114 	return -FDT_ERR_NOTFOUND;
115 }
116 
117 int fdt_subnode_offset_namelen(const void *fdt, int offset,
118 			       const char *name, int namelen)
119 {
120 	int depth;
121 
122 	FDT_CHECK_HEADER(fdt);
123 
124 	for (depth = 0;
125 	     (offset >= 0) && (depth >= 0);
126 	     offset = fdt_next_node(fdt, offset, &depth))
127 		if ((depth == 1)
128 		    && _fdt_nodename_eq(fdt, offset, name, namelen))
129 			return offset;
130 
131 	if (depth < 0)
132 		return -FDT_ERR_NOTFOUND;
133 	return offset; /* error */
134 }
135 
136 int fdt_subnode_offset(const void *fdt, int parentoffset,
137 		       const char *name)
138 {
139 	return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
140 }
141 
142 /*
143  * Find the next of path separator, note we need to search for both '/' and ':'
144  * and then take the first one so that we do the right thing for e.g.
145  * "foo/bar:option" and "bar:option/otheroption", both of which happen, so
146  * first searching for either ':' or '/' does not work.
147  */
148 static const char *fdt_path_next_separator(const char *path, int len)
149 {
150 	const void *sep1 = memchr(path, '/', len);
151 	const void *sep2 = memchr(path, ':', len);
152 
153 	if (sep1 && sep2)
154 		return (sep1 < sep2) ? sep1 : sep2;
155 	else if (sep1)
156 		return sep1;
157 	else
158 		return sep2;
159 }
160 
161 int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
162 {
163 	const char *end = path + namelen;
164 	const char *p = path;
165 	int offset = 0;
166 
167 	FDT_CHECK_HEADER(fdt);
168 
169 	/* see if we have an alias */
170 	if (*path != '/') {
171 		const char *q = fdt_path_next_separator(path, namelen);
172 
173 		if (!q)
174 			q = end;
175 
176 		p = fdt_get_alias_namelen(fdt, p, q - p);
177 		if (!p)
178 			return -FDT_ERR_BADPATH;
179 		offset = fdt_path_offset(fdt, p);
180 
181 		p = q;
182 	}
183 
184 	while (*p && (p < end)) {
185 		const char *q;
186 
187 		while (*p == '/')
188 			p++;
189 
190 		if (*p == '\0' || *p == ':')
191 			return offset;
192 
193 		q = fdt_path_next_separator(p, end - p);
194 		if (!q)
195 			q = end;
196 
197 		offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
198 		if (offset < 0)
199 			return offset;
200 
201 		p = q;
202 	}
203 
204 	return offset;
205 }
206 
207 int fdt_path_offset(const void *fdt, const char *path)
208 {
209 	return fdt_path_offset_namelen(fdt, path, strlen(path));
210 }
211 
212 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
213 {
214 	const struct fdt_node_header *nh = fdt_offset_ptr_(fdt, nodeoffset);
215 	int err;
216 
217 	if (((err = fdt_check_header(fdt)) != 0)
218 	    || ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
219 			goto fail;
220 
221 	if (len)
222 		*len = strlen(nh->name);
223 
224 	return nh->name;
225 
226  fail:
227 	if (len)
228 		*len = err;
229 	return NULL;
230 }
231 
232 int fdt_first_property_offset(const void *fdt, int nodeoffset)
233 {
234 	int offset;
235 
236 	if ((offset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
237 		return offset;
238 
239 	return _nextprop(fdt, offset);
240 }
241 
242 int fdt_next_property_offset(const void *fdt, int offset)
243 {
244 	if ((offset = fdt_check_prop_offset_(fdt, offset)) < 0)
245 		return offset;
246 
247 	return _nextprop(fdt, offset);
248 }
249 
250 const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
251 						      int offset,
252 						      int *lenp)
253 {
254 	int err;
255 	const struct fdt_property *prop;
256 
257 	if ((err = fdt_check_prop_offset_(fdt, offset)) < 0) {
258 		if (lenp)
259 			*lenp = err;
260 		return NULL;
261 	}
262 
263 	prop = fdt_offset_ptr_(fdt, offset);
264 
265 	if (lenp)
266 		*lenp = fdt32_to_cpu(prop->len);
267 
268 	return prop;
269 }
270 
271 const struct fdt_property *fdt_get_property_namelen(const void *fdt,
272 						    int offset,
273 						    const char *name,
274 						    int namelen, int *lenp)
275 {
276 	for (offset = fdt_first_property_offset(fdt, offset);
277 	     (offset >= 0);
278 	     (offset = fdt_next_property_offset(fdt, offset))) {
279 		const struct fdt_property *prop;
280 
281 		if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
282 			offset = -FDT_ERR_INTERNAL;
283 			break;
284 		}
285 		if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
286 				   name, namelen))
287 			return prop;
288 	}
289 
290 	if (lenp)
291 		*lenp = offset;
292 	return NULL;
293 }
294 
295 const struct fdt_property *fdt_get_property(const void *fdt,
296 					    int nodeoffset,
297 					    const char *name, int *lenp)
298 {
299 	return fdt_get_property_namelen(fdt, nodeoffset, name,
300 					strlen(name), lenp);
301 }
302 
303 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
304 				const char *name, int namelen, int *lenp)
305 {
306 	const struct fdt_property *prop;
307 
308 	prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
309 	if (!prop)
310 		return NULL;
311 
312 	return prop->data;
313 }
314 
315 const void *fdt_getprop_by_offset(const void *fdt, int offset,
316 				  const char **namep, int *lenp)
317 {
318 	const struct fdt_property *prop;
319 
320 	prop = fdt_get_property_by_offset(fdt, offset, lenp);
321 	if (!prop)
322 		return NULL;
323 	if (namep)
324 		*namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
325 	return prop->data;
326 }
327 
328 const void *fdt_getprop(const void *fdt, int nodeoffset,
329 			const char *name, int *lenp)
330 {
331 	return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
332 }
333 
334 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
335 {
336 	const fdt32_t *php;
337 	int len;
338 
339 	/* FIXME: This is a bit sub-optimal, since we potentially scan
340 	 * over all the properties twice. */
341 	php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
342 	if (!php || (len != sizeof(*php))) {
343 		php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
344 		if (!php || (len != sizeof(*php)))
345 			return 0;
346 	}
347 
348 	return fdt32_to_cpu(*php);
349 }
350 
351 const char *fdt_get_alias_namelen(const void *fdt,
352 				  const char *name, int namelen)
353 {
354 	int aliasoffset;
355 
356 	aliasoffset = fdt_path_offset(fdt, "/aliases");
357 	if (aliasoffset < 0)
358 		return NULL;
359 
360 	return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
361 }
362 
363 const char *fdt_get_alias(const void *fdt, const char *name)
364 {
365 	return fdt_get_alias_namelen(fdt, name, strlen(name));
366 }
367 
368 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
369 {
370 	int pdepth = 0, p = 0;
371 	int offset, depth, namelen;
372 	const char *name;
373 
374 	FDT_CHECK_HEADER(fdt);
375 
376 	if (buflen < 2)
377 		return -FDT_ERR_NOSPACE;
378 
379 	for (offset = 0, depth = 0;
380 	     (offset >= 0) && (offset <= nodeoffset);
381 	     offset = fdt_next_node(fdt, offset, &depth)) {
382 		while (pdepth > depth) {
383 			do {
384 				p--;
385 			} while (buf[p-1] != '/');
386 			pdepth--;
387 		}
388 
389 		if (pdepth >= depth) {
390 			name = fdt_get_name(fdt, offset, &namelen);
391 			if (!name)
392 				return namelen;
393 			if ((p + namelen + 1) <= buflen) {
394 				memcpy(buf + p, name, namelen);
395 				p += namelen;
396 				buf[p++] = '/';
397 				pdepth++;
398 			}
399 		}
400 
401 		if (offset == nodeoffset) {
402 			if (pdepth < (depth + 1))
403 				return -FDT_ERR_NOSPACE;
404 
405 			if (p > 1) /* special case so that root path is "/", not "" */
406 				p--;
407 			buf[p] = '\0';
408 			return 0;
409 		}
410 	}
411 
412 	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
413 		return -FDT_ERR_BADOFFSET;
414 	else if (offset == -FDT_ERR_BADOFFSET)
415 		return -FDT_ERR_BADSTRUCTURE;
416 
417 	return offset; /* error from fdt_next_node() */
418 }
419 
420 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
421 				 int supernodedepth, int *nodedepth)
422 {
423 	int offset, depth;
424 	int supernodeoffset = -FDT_ERR_INTERNAL;
425 
426 	FDT_CHECK_HEADER(fdt);
427 
428 	if (supernodedepth < 0)
429 		return -FDT_ERR_NOTFOUND;
430 
431 	for (offset = 0, depth = 0;
432 	     (offset >= 0) && (offset <= nodeoffset);
433 	     offset = fdt_next_node(fdt, offset, &depth)) {
434 		if (depth == supernodedepth)
435 			supernodeoffset = offset;
436 
437 		if (offset == nodeoffset) {
438 			if (nodedepth)
439 				*nodedepth = depth;
440 
441 			if (supernodedepth > depth)
442 				return -FDT_ERR_NOTFOUND;
443 			else
444 				return supernodeoffset;
445 		}
446 	}
447 
448 	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
449 		return -FDT_ERR_BADOFFSET;
450 	else if (offset == -FDT_ERR_BADOFFSET)
451 		return -FDT_ERR_BADSTRUCTURE;
452 
453 	return offset; /* error from fdt_next_node() */
454 }
455 
456 int fdt_node_depth(const void *fdt, int nodeoffset)
457 {
458 	int nodedepth;
459 	int err;
460 
461 	err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
462 	if (err)
463 		return (err < 0) ? err : -FDT_ERR_INTERNAL;
464 	return nodedepth;
465 }
466 
467 int fdt_parent_offset(const void *fdt, int nodeoffset)
468 {
469 	int nodedepth = fdt_node_depth(fdt, nodeoffset);
470 
471 	if (nodedepth < 0)
472 		return nodedepth;
473 	return fdt_supernode_atdepth_offset(fdt, nodeoffset,
474 					    nodedepth - 1, NULL);
475 }
476 
477 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
478 				  const char *propname,
479 				  const void *propval, int proplen)
480 {
481 	int offset;
482 	const void *val;
483 	int len;
484 
485 	FDT_CHECK_HEADER(fdt);
486 
487 	/* FIXME: The algorithm here is pretty horrible: we scan each
488 	 * property of a node in fdt_getprop(), then if that didn't
489 	 * find what we want, we scan over them again making our way
490 	 * to the next node.  Still it's the easiest to implement
491 	 * approach; performance can come later. */
492 	for (offset = fdt_next_node(fdt, startoffset, NULL);
493 	     offset >= 0;
494 	     offset = fdt_next_node(fdt, offset, NULL)) {
495 		val = fdt_getprop(fdt, offset, propname, &len);
496 		if (val && (len == proplen)
497 		    && (memcmp(val, propval, len) == 0))
498 			return offset;
499 	}
500 
501 	return offset; /* error from fdt_next_node() */
502 }
503 
504 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
505 {
506 	int offset;
507 
508 	if ((phandle == 0) || (phandle == -1))
509 		return -FDT_ERR_BADPHANDLE;
510 
511 	FDT_CHECK_HEADER(fdt);
512 
513 	/* FIXME: The algorithm here is pretty horrible: we
514 	 * potentially scan each property of a node in
515 	 * fdt_get_phandle(), then if that didn't find what
516 	 * we want, we scan over them again making our way to the next
517 	 * node.  Still it's the easiest to implement approach;
518 	 * performance can come later. */
519 	for (offset = fdt_next_node(fdt, -1, NULL);
520 	     offset >= 0;
521 	     offset = fdt_next_node(fdt, offset, NULL)) {
522 		if (fdt_get_phandle(fdt, offset) == phandle)
523 			return offset;
524 	}
525 
526 	return offset; /* error from fdt_next_node() */
527 }
528 
529 int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
530 {
531 	int len = strlen(str);
532 	const char *p;
533 
534 	while (listlen >= len) {
535 		if (memcmp(str, strlist, len+1) == 0)
536 			return 1;
537 		p = memchr(strlist, '\0', listlen);
538 		if (!p)
539 			return 0; /* malformed strlist.. */
540 		listlen -= (p-strlist) + 1;
541 		strlist = p + 1;
542 	}
543 	return 0;
544 }
545 
546 int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
547 {
548 	const char *list, *end;
549 	int length, count = 0;
550 
551 	list = fdt_getprop(fdt, nodeoffset, property, &length);
552 	if (!list)
553 		return length;
554 
555 	end = list + length;
556 
557 	while (list < end) {
558 		length = strnlen(list, end - list) + 1;
559 
560 		/* Abort if the last string isn't properly NUL-terminated. */
561 		if (list + length > end)
562 			return -FDT_ERR_BADVALUE;
563 
564 		list += length;
565 		count++;
566 	}
567 
568 	return count;
569 }
570 
571 int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
572 			  const char *string)
573 {
574 	int length, len, idx = 0;
575 	const char *list, *end;
576 
577 	list = fdt_getprop(fdt, nodeoffset, property, &length);
578 	if (!list)
579 		return length;
580 
581 	len = strlen(string) + 1;
582 	end = list + length;
583 
584 	while (list < end) {
585 		length = strnlen(list, end - list) + 1;
586 
587 		/* Abort if the last string isn't properly NUL-terminated. */
588 		if (list + length > end)
589 			return -FDT_ERR_BADVALUE;
590 
591 		if (length == len && memcmp(list, string, length) == 0)
592 			return idx;
593 
594 		list += length;
595 		idx++;
596 	}
597 
598 	return -FDT_ERR_NOTFOUND;
599 }
600 
601 const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
602 			       const char *property, int idx,
603 			       int *lenp)
604 {
605 	const char *list, *end;
606 	int length;
607 
608 	list = fdt_getprop(fdt, nodeoffset, property, &length);
609 	if (!list) {
610 		if (lenp)
611 			*lenp = length;
612 
613 		return NULL;
614 	}
615 
616 	end = list + length;
617 
618 	while (list < end) {
619 		length = strnlen(list, end - list) + 1;
620 
621 		/* Abort if the last string isn't properly NUL-terminated. */
622 		if (list + length > end) {
623 			if (lenp)
624 				*lenp = -FDT_ERR_BADVALUE;
625 
626 			return NULL;
627 		}
628 
629 		if (idx == 0) {
630 			if (lenp)
631 				*lenp = length - 1;
632 
633 			return list;
634 		}
635 
636 		list += length;
637 		idx--;
638 	}
639 
640 	if (lenp)
641 		*lenp = -FDT_ERR_NOTFOUND;
642 
643 	return NULL;
644 }
645 
646 int fdt_node_check_compatible(const void *fdt, int nodeoffset,
647 			      const char *compatible)
648 {
649 	const void *prop;
650 	int len;
651 
652 	prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
653 	if (!prop)
654 		return len;
655 
656 	return !fdt_stringlist_contains(prop, len, compatible);
657 }
658 
659 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
660 				  const char *compatible)
661 {
662 	int offset, err;
663 
664 	FDT_CHECK_HEADER(fdt);
665 
666 	/* FIXME: The algorithm here is pretty horrible: we scan each
667 	 * property of a node in fdt_node_check_compatible(), then if
668 	 * that didn't find what we want, we scan over them again
669 	 * making our way to the next node.  Still it's the easiest to
670 	 * implement approach; performance can come later. */
671 	for (offset = fdt_next_node(fdt, startoffset, NULL);
672 	     offset >= 0;
673 	     offset = fdt_next_node(fdt, offset, NULL)) {
674 		err = fdt_node_check_compatible(fdt, offset, compatible);
675 		if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
676 			return err;
677 		else if (err == 0)
678 			return offset;
679 	}
680 
681 	return offset; /* error from fdt_next_node() */
682 }
683