xref: /linux/scripts/dtc/libfdt/fdt_ro.c (revision ee057c8c194b9283f4137b253b70e292693a39f0) 
1 // SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause)
2 /*
3  * libfdt - Flat Device Tree manipulation
4  * Copyright (C) 2006 David Gibson, IBM Corporation.
5  */
6 #include "libfdt_env.h"
7 
8 #include <fdt.h>
9 #include <libfdt.h>
10 
11 #include "libfdt_internal.h"
12 
13 static int fdt_nodename_eq_(const void *fdt, int offset,
14 			    const char *s, int len)
15 {
16 	int olen;
17 	const char *p = fdt_get_name(fdt, offset, &olen);
18 
19 	if (!p || olen < len)
20 		/* short match */
21 		return 0;
22 
23 	if (memcmp(p, s, len) != 0)
24 		return 0;
25 
26 	if (p[len] == '\0')
27 		return 1;
28 	else if (!memchr(s, '@', len) && (p[len] == '@'))
29 		return 1;
30 	else
31 		return 0;
32 }
33 
34 const char *fdt_get_string(const void *fdt, int stroffset, int *lenp)
35 {
36 	int32_t totalsize;
37 	uint32_t absoffset;
38 	size_t len;
39 	int err;
40 	const char *s, *n;
41 
42 	if (can_assume(VALID_INPUT)) {
43 		s = (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
44 
45 		if (lenp)
46 			*lenp = strlen(s);
47 		return s;
48 	}
49 	totalsize = fdt_ro_probe_(fdt);
50 	err = totalsize;
51 	if (totalsize < 0)
52 		goto fail;
53 
54 	err = -FDT_ERR_BADOFFSET;
55 	absoffset = stroffset + fdt_off_dt_strings(fdt);
56 	if (absoffset >= (unsigned)totalsize)
57 		goto fail;
58 	len = totalsize - absoffset;
59 
60 	if (fdt_magic(fdt) == FDT_MAGIC) {
61 		if (stroffset < 0)
62 			goto fail;
63 		if (can_assume(LATEST) || fdt_version(fdt) >= 17) {
64 			if ((unsigned)stroffset >= fdt_size_dt_strings(fdt))
65 				goto fail;
66 			if ((fdt_size_dt_strings(fdt) - stroffset) < len)
67 				len = fdt_size_dt_strings(fdt) - stroffset;
68 		}
69 	} else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
70 		unsigned int sw_stroffset = -stroffset;
71 
72 		if ((stroffset >= 0) ||
73 		    (sw_stroffset > fdt_size_dt_strings(fdt)))
74 			goto fail;
75 		if (sw_stroffset < len)
76 			len = sw_stroffset;
77 	} else {
78 		err = -FDT_ERR_INTERNAL;
79 		goto fail;
80 	}
81 
82 	s = (const char *)fdt + absoffset;
83 	n = memchr(s, '\0', len);
84 	if (!n) {
85 		/* missing terminating NULL */
86 		err = -FDT_ERR_TRUNCATED;
87 		goto fail;
88 	}
89 
90 	if (lenp)
91 		*lenp = n - s;
92 	return s;
93 
94 fail:
95 	if (lenp)
96 		*lenp = err;
97 	return NULL;
98 }
99 
100 const char *fdt_string(const void *fdt, int stroffset)
101 {
102 	return fdt_get_string(fdt, stroffset, NULL);
103 }
104 
105 static int fdt_string_eq_(const void *fdt, int stroffset,
106 			  const char *s, int len)
107 {
108 	int slen;
109 	const char *p = fdt_get_string(fdt, stroffset, &slen);
110 
111 	return p && (slen == len) && (memcmp(p, s, len) == 0);
112 }
113 
114 int fdt_find_max_phandle(const void *fdt, uint32_t *phandle)
115 {
116 	uint32_t max = 0;
117 	int offset = -1;
118 
119 	while (true) {
120 		uint32_t value;
121 
122 		offset = fdt_next_node(fdt, offset, NULL);
123 		if (offset < 0) {
124 			if (offset == -FDT_ERR_NOTFOUND)
125 				break;
126 
127 			return offset;
128 		}
129 
130 		value = fdt_get_phandle(fdt, offset);
131 
132 		if (value > max)
133 			max = value;
134 	}
135 
136 	if (phandle)
137 		*phandle = max;
138 
139 	return 0;
140 }
141 
142 int fdt_generate_phandle(const void *fdt, uint32_t *phandle)
143 {
144 	uint32_t max;
145 	int err;
146 
147 	err = fdt_find_max_phandle(fdt, &max);
148 	if (err < 0)
149 		return err;
150 
151 	if (max == FDT_MAX_PHANDLE)
152 		return -FDT_ERR_NOPHANDLES;
153 
154 	if (phandle)
155 		*phandle = max + 1;
156 
157 	return 0;
158 }
159 
160 static const struct fdt_reserve_entry *fdt_mem_rsv(const void *fdt, int n)
161 {
162 	unsigned int offset = n * sizeof(struct fdt_reserve_entry);
163 	unsigned int absoffset = fdt_off_mem_rsvmap(fdt) + offset;
164 
165 	if (!can_assume(VALID_INPUT)) {
166 		if (absoffset < fdt_off_mem_rsvmap(fdt))
167 			return NULL;
168 		if (absoffset > fdt_totalsize(fdt) -
169 		    sizeof(struct fdt_reserve_entry))
170 			return NULL;
171 	}
172 	return fdt_mem_rsv_(fdt, n);
173 }
174 
175 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
176 {
177 	const struct fdt_reserve_entry *re;
178 
179 	FDT_RO_PROBE(fdt);
180 	re = fdt_mem_rsv(fdt, n);
181 	if (!can_assume(VALID_INPUT) && !re)
182 		return -FDT_ERR_BADOFFSET;
183 
184 	*address = fdt64_ld_(&re->address);
185 	*size = fdt64_ld_(&re->size);
186 	return 0;
187 }
188 
189 int fdt_num_mem_rsv(const void *fdt)
190 {
191 	int i;
192 	const struct fdt_reserve_entry *re;
193 
194 	for (i = 0; (re = fdt_mem_rsv(fdt, i)) != NULL; i++) {
195 		if (fdt64_ld_(&re->size) == 0)
196 			return i;
197 	}
198 	return -FDT_ERR_TRUNCATED;
199 }
200 
201 static int nextprop_(const void *fdt, int offset)
202 {
203 	uint32_t tag;
204 	int nextoffset;
205 
206 	do {
207 		tag = fdt_next_tag(fdt, offset, &nextoffset);
208 
209 		switch (tag) {
210 		case FDT_END:
211 			if (nextoffset >= 0)
212 				return -FDT_ERR_BADSTRUCTURE;
213 			else
214 				return nextoffset;
215 
216 		case FDT_PROP:
217 			return offset;
218 		}
219 		offset = nextoffset;
220 	} while (tag == FDT_NOP);
221 
222 	return -FDT_ERR_NOTFOUND;
223 }
224 
225 int fdt_subnode_offset_namelen(const void *fdt, int offset,
226 			       const char *name, int namelen)
227 {
228 	int depth;
229 
230 	FDT_RO_PROBE(fdt);
231 
232 	for (depth = 0;
233 	     (offset >= 0) && (depth >= 0);
234 	     offset = fdt_next_node(fdt, offset, &depth))
235 		if ((depth == 1)
236 		    && fdt_nodename_eq_(fdt, offset, name, namelen))
237 			return offset;
238 
239 	if (depth < 0)
240 		return -FDT_ERR_NOTFOUND;
241 	return offset; /* error */
242 }
243 
244 int fdt_subnode_offset(const void *fdt, int parentoffset,
245 		       const char *name)
246 {
247 	return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
248 }
249 
250 int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
251 {
252 	const char *end = path + namelen;
253 	const char *p = path;
254 	int offset = 0;
255 
256 	FDT_RO_PROBE(fdt);
257 
258 	if (!can_assume(VALID_INPUT) && namelen <= 0)
259 		return -FDT_ERR_BADPATH;
260 
261 	/* see if we have an alias */
262 	if (*path != '/') {
263 		const char *q = memchr(path, '/', end - p);
264 
265 		if (!q)
266 			q = end;
267 
268 		p = fdt_get_alias_namelen(fdt, p, q - p);
269 		if (!p)
270 			return -FDT_ERR_BADPATH;
271 		offset = fdt_path_offset(fdt, p);
272 
273 		p = q;
274 	}
275 
276 	while (p < end) {
277 		const char *q;
278 
279 		while (*p == '/') {
280 			p++;
281 			if (p == end)
282 				return offset;
283 		}
284 		q = memchr(p, '/', end - p);
285 		if (! q)
286 			q = end;
287 
288 		offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
289 		if (offset < 0)
290 			return offset;
291 
292 		p = q;
293 	}
294 
295 	return offset;
296 }
297 
298 int fdt_path_offset(const void *fdt, const char *path)
299 {
300 	return fdt_path_offset_namelen(fdt, path, strlen(path));
301 }
302 
303 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
304 {
305 	const struct fdt_node_header *nh = fdt_offset_ptr_(fdt, nodeoffset);
306 	const char *nameptr;
307 	int err;
308 
309 	if (((err = fdt_ro_probe_(fdt)) < 0)
310 	    || ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
311 			goto fail;
312 
313 	nameptr = nh->name;
314 
315 	if (!can_assume(LATEST) && fdt_version(fdt) < 0x10) {
316 		/*
317 		 * For old FDT versions, match the naming conventions of V16:
318 		 * give only the leaf name (after all /). The actual tree
319 		 * contents are loosely checked.
320 		 */
321 		const char *leaf;
322 		leaf = strrchr(nameptr, '/');
323 		if (leaf == NULL) {
324 			err = -FDT_ERR_BADSTRUCTURE;
325 			goto fail;
326 		}
327 		nameptr = leaf+1;
328 	}
329 
330 	if (len)
331 		*len = strlen(nameptr);
332 
333 	return nameptr;
334 
335  fail:
336 	if (len)
337 		*len = err;
338 	return NULL;
339 }
340 
341 int fdt_first_property_offset(const void *fdt, int nodeoffset)
342 {
343 	int offset;
344 
345 	if ((offset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
346 		return offset;
347 
348 	return nextprop_(fdt, offset);
349 }
350 
351 int fdt_next_property_offset(const void *fdt, int offset)
352 {
353 	if ((offset = fdt_check_prop_offset_(fdt, offset)) < 0)
354 		return offset;
355 
356 	return nextprop_(fdt, offset);
357 }
358 
359 static const struct fdt_property *fdt_get_property_by_offset_(const void *fdt,
360 						              int offset,
361 						              int *lenp)
362 {
363 	int err;
364 	const struct fdt_property *prop;
365 
366 	if (!can_assume(VALID_INPUT) &&
367 	    (err = fdt_check_prop_offset_(fdt, offset)) < 0) {
368 		if (lenp)
369 			*lenp = err;
370 		return NULL;
371 	}
372 
373 	prop = fdt_offset_ptr_(fdt, offset);
374 
375 	if (lenp)
376 		*lenp = fdt32_ld_(&prop->len);
377 
378 	return prop;
379 }
380 
381 const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
382 						      int offset,
383 						      int *lenp)
384 {
385 	/* Prior to version 16, properties may need realignment
386 	 * and this API does not work. fdt_getprop_*() will, however. */
387 
388 	if (!can_assume(LATEST) && fdt_version(fdt) < 0x10) {
389 		if (lenp)
390 			*lenp = -FDT_ERR_BADVERSION;
391 		return NULL;
392 	}
393 
394 	return fdt_get_property_by_offset_(fdt, offset, lenp);
395 }
396 
397 static const struct fdt_property *fdt_get_property_namelen_(const void *fdt,
398 						            int offset,
399 						            const char *name,
400 						            int namelen,
401 							    int *lenp,
402 							    int *poffset)
403 {
404 	for (offset = fdt_first_property_offset(fdt, offset);
405 	     (offset >= 0);
406 	     (offset = fdt_next_property_offset(fdt, offset))) {
407 		const struct fdt_property *prop;
408 
409 		prop = fdt_get_property_by_offset_(fdt, offset, lenp);
410 		if (!can_assume(LIBFDT_FLAWLESS) && !prop) {
411 			offset = -FDT_ERR_INTERNAL;
412 			break;
413 		}
414 		if (fdt_string_eq_(fdt, fdt32_ld_(&prop->nameoff),
415 				   name, namelen)) {
416 			if (poffset)
417 				*poffset = offset;
418 			return prop;
419 		}
420 	}
421 
422 	if (lenp)
423 		*lenp = offset;
424 	return NULL;
425 }
426 
427 
428 const struct fdt_property *fdt_get_property_namelen(const void *fdt,
429 						    int offset,
430 						    const char *name,
431 						    int namelen, int *lenp)
432 {
433 	/* Prior to version 16, properties may need realignment
434 	 * and this API does not work. fdt_getprop_*() will, however. */
435 	if (!can_assume(LATEST) && fdt_version(fdt) < 0x10) {
436 		if (lenp)
437 			*lenp = -FDT_ERR_BADVERSION;
438 		return NULL;
439 	}
440 
441 	return fdt_get_property_namelen_(fdt, offset, name, namelen, lenp,
442 					 NULL);
443 }
444 
445 
446 const struct fdt_property *fdt_get_property(const void *fdt,
447 					    int nodeoffset,
448 					    const char *name, int *lenp)
449 {
450 	return fdt_get_property_namelen(fdt, nodeoffset, name,
451 					strlen(name), lenp);
452 }
453 
454 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
455 				const char *name, int namelen, int *lenp)
456 {
457 	int poffset;
458 	const struct fdt_property *prop;
459 
460 	prop = fdt_get_property_namelen_(fdt, nodeoffset, name, namelen, lenp,
461 					 &poffset);
462 	if (!prop)
463 		return NULL;
464 
465 	/* Handle realignment */
466 	if (!can_assume(LATEST) && fdt_version(fdt) < 0x10 &&
467 	    (poffset + sizeof(*prop)) % 8 && fdt32_ld_(&prop->len) >= 8)
468 		return prop->data + 4;
469 	return prop->data;
470 }
471 
472 const void *fdt_getprop_by_offset(const void *fdt, int offset,
473 				  const char **namep, int *lenp)
474 {
475 	const struct fdt_property *prop;
476 
477 	prop = fdt_get_property_by_offset_(fdt, offset, lenp);
478 	if (!prop)
479 		return NULL;
480 	if (namep) {
481 		const char *name;
482 		int namelen;
483 
484 		if (!can_assume(VALID_INPUT)) {
485 			name = fdt_get_string(fdt, fdt32_ld_(&prop->nameoff),
486 					      &namelen);
487 			*namep = name;
488 			if (!name) {
489 				if (lenp)
490 					*lenp = namelen;
491 				return NULL;
492 			}
493 		} else {
494 			*namep = fdt_string(fdt, fdt32_ld_(&prop->nameoff));
495 		}
496 	}
497 
498 	/* Handle realignment */
499 	if (!can_assume(LATEST) && fdt_version(fdt) < 0x10 &&
500 	    (offset + sizeof(*prop)) % 8 && fdt32_ld_(&prop->len) >= 8)
501 		return prop->data + 4;
502 	return prop->data;
503 }
504 
505 const void *fdt_getprop(const void *fdt, int nodeoffset,
506 			const char *name, int *lenp)
507 {
508 	return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
509 }
510 
511 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
512 {
513 	const fdt32_t *php;
514 	int len;
515 
516 	/* FIXME: This is a bit sub-optimal, since we potentially scan
517 	 * over all the properties twice. */
518 	php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
519 	if (!php || (len != sizeof(*php))) {
520 		php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
521 		if (!php || (len != sizeof(*php)))
522 			return 0;
523 	}
524 
525 	return fdt32_ld_(php);
526 }
527 
528 static const void *fdt_path_getprop_namelen(const void *fdt, const char *path,
529 					    const char *propname, int propnamelen,
530 					    int *lenp)
531 {
532 	int offset = fdt_path_offset(fdt, path);
533 
534 	if (offset < 0)
535 		return NULL;
536 
537 	return fdt_getprop_namelen(fdt, offset, propname, propnamelen, lenp);
538 }
539 
540 const char *fdt_get_alias_namelen(const void *fdt,
541 				  const char *name, int namelen)
542 {
543 	int len;
544 	const char *alias;
545 
546 	alias = fdt_path_getprop_namelen(fdt, "/aliases", name, namelen, &len);
547 
548 	if (!can_assume(VALID_DTB) &&
549 	    !(alias && len > 0 && alias[len - 1] == '\0' && *alias == '/'))
550 		return NULL;
551 
552 	return alias;
553 }
554 
555 const char *fdt_get_alias(const void *fdt, const char *name)
556 {
557 	return fdt_get_alias_namelen(fdt, name, strlen(name));
558 }
559 
560 const char *fdt_get_symbol_namelen(const void *fdt,
561 				   const char *name, int namelen)
562 {
563 	return fdt_path_getprop_namelen(fdt, "/__symbols__", name, namelen, NULL);
564 }
565 
566 const char *fdt_get_symbol(const void *fdt, const char *name)
567 {
568 	return fdt_get_symbol_namelen(fdt, name, strlen(name));
569 }
570 
571 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
572 {
573 	int pdepth = 0, p = 0;
574 	int offset, depth, namelen;
575 	const char *name;
576 
577 	FDT_RO_PROBE(fdt);
578 
579 	if (buflen < 2)
580 		return -FDT_ERR_NOSPACE;
581 
582 	for (offset = 0, depth = 0;
583 	     (offset >= 0) && (offset <= nodeoffset);
584 	     offset = fdt_next_node(fdt, offset, &depth)) {
585 		while (pdepth > depth) {
586 			do {
587 				p--;
588 			} while (buf[p-1] != '/');
589 			pdepth--;
590 		}
591 
592 		if (pdepth >= depth) {
593 			name = fdt_get_name(fdt, offset, &namelen);
594 			if (!name)
595 				return namelen;
596 			if ((p + namelen + 1) <= buflen) {
597 				memcpy(buf + p, name, namelen);
598 				p += namelen;
599 				buf[p++] = '/';
600 				pdepth++;
601 			}
602 		}
603 
604 		if (offset == nodeoffset) {
605 			if (pdepth < (depth + 1))
606 				return -FDT_ERR_NOSPACE;
607 
608 			if (p > 1) /* special case so that root path is "/", not "" */
609 				p--;
610 			buf[p] = '\0';
611 			return 0;
612 		}
613 	}
614 
615 	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
616 		return -FDT_ERR_BADOFFSET;
617 	else if (offset == -FDT_ERR_BADOFFSET)
618 		return -FDT_ERR_BADSTRUCTURE;
619 
620 	return offset; /* error from fdt_next_node() */
621 }
622 
623 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
624 				 int supernodedepth, int *nodedepth)
625 {
626 	int offset, depth;
627 	int supernodeoffset = -FDT_ERR_INTERNAL;
628 
629 	FDT_RO_PROBE(fdt);
630 
631 	if (supernodedepth < 0)
632 		return -FDT_ERR_NOTFOUND;
633 
634 	for (offset = 0, depth = 0;
635 	     (offset >= 0) && (offset <= nodeoffset);
636 	     offset = fdt_next_node(fdt, offset, &depth)) {
637 		if (depth == supernodedepth)
638 			supernodeoffset = offset;
639 
640 		if (offset == nodeoffset) {
641 			if (nodedepth)
642 				*nodedepth = depth;
643 
644 			if (supernodedepth > depth)
645 				return -FDT_ERR_NOTFOUND;
646 			else
647 				return supernodeoffset;
648 		}
649 	}
650 
651 	if (!can_assume(VALID_INPUT)) {
652 		if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
653 			return -FDT_ERR_BADOFFSET;
654 		else if (offset == -FDT_ERR_BADOFFSET)
655 			return -FDT_ERR_BADSTRUCTURE;
656 	}
657 
658 	return offset; /* error from fdt_next_node() */
659 }
660 
661 int fdt_node_depth(const void *fdt, int nodeoffset)
662 {
663 	int nodedepth;
664 	int err;
665 
666 	err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
667 	if (err)
668 		return (can_assume(LIBFDT_FLAWLESS) || err < 0) ? err :
669 			-FDT_ERR_INTERNAL;
670 	return nodedepth;
671 }
672 
673 int fdt_parent_offset(const void *fdt, int nodeoffset)
674 {
675 	int nodedepth = fdt_node_depth(fdt, nodeoffset);
676 
677 	if (nodedepth < 0)
678 		return nodedepth;
679 	return fdt_supernode_atdepth_offset(fdt, nodeoffset,
680 					    nodedepth - 1, NULL);
681 }
682 
683 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
684 				  const char *propname,
685 				  const void *propval, int proplen)
686 {
687 	int offset;
688 	const void *val;
689 	int len;
690 
691 	FDT_RO_PROBE(fdt);
692 
693 	/* FIXME: The algorithm here is pretty horrible: we scan each
694 	 * property of a node in fdt_getprop(), then if that didn't
695 	 * find what we want, we scan over them again making our way
696 	 * to the next node.  Still it's the easiest to implement
697 	 * approach; performance can come later. */
698 	for (offset = fdt_next_node(fdt, startoffset, NULL);
699 	     offset >= 0;
700 	     offset = fdt_next_node(fdt, offset, NULL)) {
701 		val = fdt_getprop(fdt, offset, propname, &len);
702 		if (val && (len == proplen)
703 		    && (memcmp(val, propval, len) == 0))
704 			return offset;
705 	}
706 
707 	return offset; /* error from fdt_next_node() */
708 }
709 
710 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
711 {
712 	int offset;
713 
714 	if ((phandle == 0) || (phandle == ~0U))
715 		return -FDT_ERR_BADPHANDLE;
716 
717 	FDT_RO_PROBE(fdt);
718 
719 	/* FIXME: The algorithm here is pretty horrible: we
720 	 * potentially scan each property of a node in
721 	 * fdt_get_phandle(), then if that didn't find what
722 	 * we want, we scan over them again making our way to the next
723 	 * node.  Still it's the easiest to implement approach;
724 	 * performance can come later. */
725 	for (offset = fdt_next_node(fdt, -1, NULL);
726 	     offset >= 0;
727 	     offset = fdt_next_node(fdt, offset, NULL)) {
728 		if (fdt_get_phandle(fdt, offset) == phandle)
729 			return offset;
730 	}
731 
732 	return offset; /* error from fdt_next_node() */
733 }
734 
735 int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
736 {
737 	int len = strlen(str);
738 	const char *p;
739 
740 	while (listlen >= len) {
741 		if (memcmp(str, strlist, len+1) == 0)
742 			return 1;
743 		p = memchr(strlist, '\0', listlen);
744 		if (!p)
745 			return 0; /* malformed strlist.. */
746 		listlen -= (p-strlist) + 1;
747 		strlist = p + 1;
748 	}
749 	return 0;
750 }
751 
752 int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
753 {
754 	const char *list, *end;
755 	int length, count = 0;
756 
757 	list = fdt_getprop(fdt, nodeoffset, property, &length);
758 	if (!list)
759 		return length;
760 
761 	end = list + length;
762 
763 	while (list < end) {
764 		length = strnlen(list, end - list) + 1;
765 
766 		/* Abort if the last string isn't properly NUL-terminated. */
767 		if (list + length > end)
768 			return -FDT_ERR_BADVALUE;
769 
770 		list += length;
771 		count++;
772 	}
773 
774 	return count;
775 }
776 
777 int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
778 			  const char *string)
779 {
780 	int length, len, idx = 0;
781 	const char *list, *end;
782 
783 	list = fdt_getprop(fdt, nodeoffset, property, &length);
784 	if (!list)
785 		return length;
786 
787 	len = strlen(string) + 1;
788 	end = list + length;
789 
790 	while (list < end) {
791 		length = strnlen(list, end - list) + 1;
792 
793 		/* Abort if the last string isn't properly NUL-terminated. */
794 		if (list + length > end)
795 			return -FDT_ERR_BADVALUE;
796 
797 		if (length == len && memcmp(list, string, length) == 0)
798 			return idx;
799 
800 		list += length;
801 		idx++;
802 	}
803 
804 	return -FDT_ERR_NOTFOUND;
805 }
806 
807 const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
808 			       const char *property, int idx,
809 			       int *lenp)
810 {
811 	const char *list, *end;
812 	int length;
813 
814 	list = fdt_getprop(fdt, nodeoffset, property, &length);
815 	if (!list) {
816 		if (lenp)
817 			*lenp = length;
818 
819 		return NULL;
820 	}
821 
822 	end = list + length;
823 
824 	while (list < end) {
825 		length = strnlen(list, end - list) + 1;
826 
827 		/* Abort if the last string isn't properly NUL-terminated. */
828 		if (list + length > end) {
829 			if (lenp)
830 				*lenp = -FDT_ERR_BADVALUE;
831 
832 			return NULL;
833 		}
834 
835 		if (idx == 0) {
836 			if (lenp)
837 				*lenp = length - 1;
838 
839 			return list;
840 		}
841 
842 		list += length;
843 		idx--;
844 	}
845 
846 	if (lenp)
847 		*lenp = -FDT_ERR_NOTFOUND;
848 
849 	return NULL;
850 }
851 
852 int fdt_node_check_compatible(const void *fdt, int nodeoffset,
853 			      const char *compatible)
854 {
855 	const void *prop;
856 	int len;
857 
858 	prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
859 	if (!prop)
860 		return len;
861 
862 	return !fdt_stringlist_contains(prop, len, compatible);
863 }
864 
865 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
866 				  const char *compatible)
867 {
868 	int offset, err;
869 
870 	FDT_RO_PROBE(fdt);
871 
872 	/* FIXME: The algorithm here is pretty horrible: we scan each
873 	 * property of a node in fdt_node_check_compatible(), then if
874 	 * that didn't find what we want, we scan over them again
875 	 * making our way to the next node.  Still it's the easiest to
876 	 * implement approach; performance can come later. */
877 	for (offset = fdt_next_node(fdt, startoffset, NULL);
878 	     offset >= 0;
879 	     offset = fdt_next_node(fdt, offset, NULL)) {
880 		err = fdt_node_check_compatible(fdt, offset, compatible);
881 		if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
882 			return err;
883 		else if (err == 0)
884 			return offset;
885 	}
886 
887 	return offset; /* error from fdt_next_node() */
888 }
889