• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * libfdt - Flat Device Tree manipulation
3  * Copyright (C) 2006 David Gibson, IBM Corporation.
4  *
5  * libfdt is dual licensed: you can use it either under the terms of
6  * the GPL, or the BSD license, at your option.
7  *
8  *  a) This library is free software; you can redistribute it and/or
9  *     modify it under the terms of the GNU General Public License as
10  *     published by the Free Software Foundation; either version 2 of the
11  *     License, or (at your option) any later version.
12  *
13  *     This library is distributed in the hope that it will be useful,
14  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *     GNU General Public License for more details.
17  *
18  *     You should have received a copy of the GNU General Public
19  *     License along with this library; if not, write to the Free
20  *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
21  *     MA 02110-1301 USA
22  *
23  * Alternatively,
24  *
25  *  b) Redistribution and use in source and binary forms, with or
26  *     without modification, are permitted provided that the following
27  *     conditions are met:
28  *
29  *     1. Redistributions of source code must retain the above
30  *        copyright notice, this list of conditions and the following
31  *        disclaimer.
32  *     2. Redistributions in binary form must reproduce the above
33  *        copyright notice, this list of conditions and the following
34  *        disclaimer in the documentation and/or other materials
35  *        provided with the distribution.
36  *
37  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
38  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
39  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
40  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
41  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
42  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
47  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
48  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
49  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
50  */
51 #include "libfdt_env.h"
52 
53 #include <fdt.h>
54 #include <libfdt.h>
55 
56 #include "libfdt_internal.h"
57 
_fdt_nodename_eq(const void * fdt,int offset,const char * s,int len)58 static int _fdt_nodename_eq(const void *fdt, int offset,
59 			    const char *s, int len)
60 {
61 	const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
62 
63 	if (! p)
64 		/* short match */
65 		return 0;
66 
67 	if (memcmp(p, s, len) != 0)
68 		return 0;
69 
70 	if (p[len] == '\0')
71 		return 1;
72 	else if (!memchr(s, '@', len) && (p[len] == '@'))
73 		return 1;
74 	else
75 		return 0;
76 }
77 
fdt_string(const void * fdt,int stroffset)78 const char *fdt_string(const void *fdt, int stroffset)
79 {
80 	return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
81 }
82 
_fdt_string_eq(const void * fdt,int stroffset,const char * s,int len)83 static int _fdt_string_eq(const void *fdt, int stroffset,
84 			  const char *s, int len)
85 {
86 	const char *p = fdt_string(fdt, stroffset);
87 
88 	return (strlen(p) == len) && (memcmp(p, s, len) == 0);
89 }
90 
fdt_get_mem_rsv(const void * fdt,int n,uint64_t * address,uint64_t * size)91 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
92 {
93 	FDT_CHECK_HEADER(fdt);
94 	*address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
95 	*size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
96 	return 0;
97 }
98 
fdt_num_mem_rsv(const void * fdt)99 int fdt_num_mem_rsv(const void *fdt)
100 {
101 	int i = 0;
102 
103 	while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
104 		i++;
105 	return i;
106 }
107 
_nextprop(const void * fdt,int offset)108 static int _nextprop(const void *fdt, int offset)
109 {
110 	uint32_t tag;
111 	int nextoffset;
112 
113 	do {
114 		tag = fdt_next_tag(fdt, offset, &nextoffset);
115 
116 		switch (tag) {
117 		case FDT_END:
118 			if (nextoffset >= 0)
119 				return -FDT_ERR_BADSTRUCTURE;
120 			else
121 				return nextoffset;
122 
123 		case FDT_PROP:
124 			return offset;
125 		}
126 		offset = nextoffset;
127 	} while (tag == FDT_NOP);
128 
129 	return -FDT_ERR_NOTFOUND;
130 }
131 
fdt_subnode_offset_namelen(const void * fdt,int offset,const char * name,int namelen)132 int fdt_subnode_offset_namelen(const void *fdt, int offset,
133 			       const char *name, int namelen)
134 {
135 	int depth;
136 
137 	FDT_CHECK_HEADER(fdt);
138 
139 	for (depth = 0;
140 	     (offset >= 0) && (depth >= 0);
141 	     offset = fdt_next_node(fdt, offset, &depth))
142 		if ((depth == 1)
143 		    && _fdt_nodename_eq(fdt, offset, name, namelen))
144 			return offset;
145 
146 	if (depth < 0)
147 		return -FDT_ERR_NOTFOUND;
148 	return offset; /* error */
149 }
150 
fdt_subnode_offset(const void * fdt,int parentoffset,const char * name)151 int fdt_subnode_offset(const void *fdt, int parentoffset,
152 		       const char *name)
153 {
154 	return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
155 }
156 
fdt_path_offset(const void * fdt,const char * path)157 int fdt_path_offset(const void *fdt, const char *path)
158 {
159 	const char *end = path + strlen(path);
160 	const char *p = path;
161 	int offset = 0;
162 
163 	FDT_CHECK_HEADER(fdt);
164 
165 	/* see if we have an alias */
166 	if (*path != '/') {
167 		const char *q = strchr(path, '/');
168 
169 		if (!q)
170 			q = end;
171 
172 		p = fdt_get_alias_namelen(fdt, p, q - p);
173 		if (!p)
174 			return -FDT_ERR_BADPATH;
175 		offset = fdt_path_offset(fdt, p);
176 
177 		p = q;
178 	}
179 
180 	while (*p) {
181 		const char *q;
182 
183 		while (*p == '/')
184 			p++;
185 		if (! *p)
186 			return offset;
187 		q = strchr(p, '/');
188 		if (! q)
189 			q = end;
190 
191 		offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
192 		if (offset < 0)
193 			return offset;
194 
195 		p = q;
196 	}
197 
198 	return offset;
199 }
200 
fdt_get_name(const void * fdt,int nodeoffset,int * len)201 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
202 {
203 	const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);
204 	int err;
205 
206 	if (((err = fdt_check_header(fdt)) != 0)
207 	    || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
208 			goto fail;
209 
210 	if (len)
211 		*len = strlen(nh->name);
212 
213 	return nh->name;
214 
215  fail:
216 	if (len)
217 		*len = err;
218 	return NULL;
219 }
220 
fdt_first_property_offset(const void * fdt,int nodeoffset)221 int fdt_first_property_offset(const void *fdt, int nodeoffset)
222 {
223 	int offset;
224 
225 	if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
226 		return offset;
227 
228 	return _nextprop(fdt, offset);
229 }
230 
fdt_next_property_offset(const void * fdt,int offset)231 int fdt_next_property_offset(const void *fdt, int offset)
232 {
233 	if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)
234 		return offset;
235 
236 	return _nextprop(fdt, offset);
237 }
238 
fdt_get_property_by_offset(const void * fdt,int offset,int * lenp)239 const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
240 						      int offset,
241 						      int *lenp)
242 {
243 	int err;
244 	const struct fdt_property *prop;
245 
246 	if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
247 		if (lenp)
248 			*lenp = err;
249 		return NULL;
250 	}
251 
252 	prop = _fdt_offset_ptr(fdt, offset);
253 
254 	if (lenp)
255 		*lenp = fdt32_to_cpu(prop->len);
256 
257 	return prop;
258 }
259 
fdt_get_property_namelen(const void * fdt,int offset,const char * name,int namelen,int * lenp)260 const struct fdt_property *fdt_get_property_namelen(const void *fdt,
261 						    int offset,
262 						    const char *name,
263 						    int namelen, int *lenp)
264 {
265 	for (offset = fdt_first_property_offset(fdt, offset);
266 	     (offset >= 0);
267 	     (offset = fdt_next_property_offset(fdt, offset))) {
268 		const struct fdt_property *prop;
269 
270 		if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
271 			offset = -FDT_ERR_INTERNAL;
272 			break;
273 		}
274 		if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
275 				   name, namelen))
276 			return prop;
277 	}
278 
279 	if (lenp)
280 		*lenp = offset;
281 	return NULL;
282 }
283 
fdt_get_property(const void * fdt,int nodeoffset,const char * name,int * lenp)284 const struct fdt_property *fdt_get_property(const void *fdt,
285 					    int nodeoffset,
286 					    const char *name, int *lenp)
287 {
288 	return fdt_get_property_namelen(fdt, nodeoffset, name,
289 					strlen(name), lenp);
290 }
291 
fdt_getprop_namelen(const void * fdt,int nodeoffset,const char * name,int namelen,int * lenp)292 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
293 				const char *name, int namelen, int *lenp)
294 {
295 	const struct fdt_property *prop;
296 
297 	prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
298 	if (! prop)
299 		return NULL;
300 
301 	return prop->data;
302 }
303 
fdt_getprop_by_offset(const void * fdt,int offset,const char ** namep,int * lenp)304 const void *fdt_getprop_by_offset(const void *fdt, int offset,
305 				  const char **namep, int *lenp)
306 {
307 	const struct fdt_property *prop;
308 
309 	prop = fdt_get_property_by_offset(fdt, offset, lenp);
310 	if (!prop)
311 		return NULL;
312 	if (namep)
313 		*namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
314 	return prop->data;
315 }
316 
fdt_getprop(const void * fdt,int nodeoffset,const char * name,int * lenp)317 const void *fdt_getprop(const void *fdt, int nodeoffset,
318 			const char *name, int *lenp)
319 {
320 	return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
321 }
322 
fdt_get_phandle(const void * fdt,int nodeoffset)323 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
324 {
325 	const uint32_t *php;
326 	int len;
327 
328 	/* FIXME: This is a bit sub-optimal, since we potentially scan
329 	 * over all the properties twice. */
330 	php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
331 	if (!php || (len != sizeof(*php))) {
332 		php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
333 		if (!php || (len != sizeof(*php)))
334 			return 0;
335 	}
336 
337 	return fdt32_to_cpu(*php);
338 }
339 
fdt_get_alias_namelen(const void * fdt,const char * name,int namelen)340 const char *fdt_get_alias_namelen(const void *fdt,
341 				  const char *name, int namelen)
342 {
343 	int aliasoffset;
344 
345 	aliasoffset = fdt_path_offset(fdt, "/aliases");
346 	if (aliasoffset < 0)
347 		return NULL;
348 
349 	return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
350 }
351 
fdt_get_alias(const void * fdt,const char * name)352 const char *fdt_get_alias(const void *fdt, const char *name)
353 {
354 	return fdt_get_alias_namelen(fdt, name, strlen(name));
355 }
356 
fdt_get_path(const void * fdt,int nodeoffset,char * buf,int buflen)357 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
358 {
359 	int pdepth = 0, p = 0;
360 	int offset, depth, namelen;
361 	const char *name;
362 
363 	FDT_CHECK_HEADER(fdt);
364 
365 	if (buflen < 2)
366 		return -FDT_ERR_NOSPACE;
367 
368 	for (offset = 0, depth = 0;
369 	     (offset >= 0) && (offset <= nodeoffset);
370 	     offset = fdt_next_node(fdt, offset, &depth)) {
371 		while (pdepth > depth) {
372 			do {
373 				p--;
374 			} while (buf[p-1] != '/');
375 			pdepth--;
376 		}
377 
378 		if (pdepth >= depth) {
379 			name = fdt_get_name(fdt, offset, &namelen);
380 			if (!name)
381 				return namelen;
382 			if ((p + namelen + 1) <= buflen) {
383 				memcpy(buf + p, name, namelen);
384 				p += namelen;
385 				buf[p++] = '/';
386 				pdepth++;
387 			}
388 		}
389 
390 		if (offset == nodeoffset) {
391 			if (pdepth < (depth + 1))
392 				return -FDT_ERR_NOSPACE;
393 
394 			if (p > 1) /* special case so that root path is "/", not "" */
395 				p--;
396 			buf[p] = '\0';
397 			return 0;
398 		}
399 	}
400 
401 	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
402 		return -FDT_ERR_BADOFFSET;
403 	else if (offset == -FDT_ERR_BADOFFSET)
404 		return -FDT_ERR_BADSTRUCTURE;
405 
406 	return offset; /* error from fdt_next_node() */
407 }
408 
fdt_supernode_atdepth_offset(const void * fdt,int nodeoffset,int supernodedepth,int * nodedepth)409 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
410 				 int supernodedepth, int *nodedepth)
411 {
412 	int offset, depth;
413 	int supernodeoffset = -FDT_ERR_INTERNAL;
414 
415 	FDT_CHECK_HEADER(fdt);
416 
417 	if (supernodedepth < 0)
418 		return -FDT_ERR_NOTFOUND;
419 
420 	for (offset = 0, depth = 0;
421 	     (offset >= 0) && (offset <= nodeoffset);
422 	     offset = fdt_next_node(fdt, offset, &depth)) {
423 		if (depth == supernodedepth)
424 			supernodeoffset = offset;
425 
426 		if (offset == nodeoffset) {
427 			if (nodedepth)
428 				*nodedepth = depth;
429 
430 			if (supernodedepth > depth)
431 				return -FDT_ERR_NOTFOUND;
432 			else
433 				return supernodeoffset;
434 		}
435 	}
436 
437 	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
438 		return -FDT_ERR_BADOFFSET;
439 	else if (offset == -FDT_ERR_BADOFFSET)
440 		return -FDT_ERR_BADSTRUCTURE;
441 
442 	return offset; /* error from fdt_next_node() */
443 }
444 
fdt_node_depth(const void * fdt,int nodeoffset)445 int fdt_node_depth(const void *fdt, int nodeoffset)
446 {
447 	int nodedepth;
448 	int err;
449 
450 	err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
451 	if (err)
452 		return (err < 0) ? err : -FDT_ERR_INTERNAL;
453 	return nodedepth;
454 }
455 
fdt_parent_offset(const void * fdt,int nodeoffset)456 int fdt_parent_offset(const void *fdt, int nodeoffset)
457 {
458 	int nodedepth = fdt_node_depth(fdt, nodeoffset);
459 
460 	if (nodedepth < 0)
461 		return nodedepth;
462 	return fdt_supernode_atdepth_offset(fdt, nodeoffset,
463 					    nodedepth - 1, NULL);
464 }
465 
fdt_node_offset_by_prop_value(const void * fdt,int startoffset,const char * propname,const void * propval,int proplen)466 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
467 				  const char *propname,
468 				  const void *propval, int proplen)
469 {
470 	int offset;
471 	const void *val;
472 	int len;
473 
474 	FDT_CHECK_HEADER(fdt);
475 
476 	/* FIXME: The algorithm here is pretty horrible: we scan each
477 	 * property of a node in fdt_getprop(), then if that didn't
478 	 * find what we want, we scan over them again making our way
479 	 * to the next node.  Still it's the easiest to implement
480 	 * approach; performance can come later. */
481 	for (offset = fdt_next_node(fdt, startoffset, NULL);
482 	     offset >= 0;
483 	     offset = fdt_next_node(fdt, offset, NULL)) {
484 		val = fdt_getprop(fdt, offset, propname, &len);
485 		if (val && (len == proplen)
486 		    && (memcmp(val, propval, len) == 0))
487 			return offset;
488 	}
489 
490 	return offset; /* error from fdt_next_node() */
491 }
492 
fdt_node_offset_by_phandle(const void * fdt,uint32_t phandle)493 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
494 {
495 	int offset;
496 
497 	if ((phandle == 0) || (phandle == -1))
498 		return -FDT_ERR_BADPHANDLE;
499 
500 	FDT_CHECK_HEADER(fdt);
501 
502 	/* FIXME: The algorithm here is pretty horrible: we
503 	 * potentially scan each property of a node in
504 	 * fdt_get_phandle(), then if that didn't find what
505 	 * we want, we scan over them again making our way to the next
506 	 * node.  Still it's the easiest to implement approach;
507 	 * performance can come later. */
508 	for (offset = fdt_next_node(fdt, -1, NULL);
509 	     offset >= 0;
510 	     offset = fdt_next_node(fdt, offset, NULL)) {
511 		if (fdt_get_phandle(fdt, offset) == phandle)
512 			return offset;
513 	}
514 
515 	return offset; /* error from fdt_next_node() */
516 }
517 
_fdt_stringlist_contains(const char * strlist,int listlen,const char * str)518 static int _fdt_stringlist_contains(const char *strlist, int listlen,
519 				    const char *str)
520 {
521 	int len = strlen(str);
522 	const char *p;
523 
524 	while (listlen >= len) {
525 		if (memcmp(str, strlist, len+1) == 0)
526 			return 1;
527 		p = memchr(strlist, '\0', listlen);
528 		if (!p)
529 			return 0; /* malformed strlist.. */
530 		listlen -= (p-strlist) + 1;
531 		strlist = p + 1;
532 	}
533 	return 0;
534 }
535 
fdt_node_check_compatible(const void * fdt,int nodeoffset,const char * compatible)536 int fdt_node_check_compatible(const void *fdt, int nodeoffset,
537 			      const char *compatible)
538 {
539 	const void *prop;
540 	int len;
541 
542 	prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
543 	if (!prop)
544 		return len;
545 	if (_fdt_stringlist_contains(prop, len, compatible))
546 		return 0;
547 	else
548 		return 1;
549 }
550 
fdt_node_offset_by_compatible(const void * fdt,int startoffset,const char * compatible)551 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
552 				  const char *compatible)
553 {
554 	int offset, err;
555 
556 	FDT_CHECK_HEADER(fdt);
557 
558 	/* FIXME: The algorithm here is pretty horrible: we scan each
559 	 * property of a node in fdt_node_check_compatible(), then if
560 	 * that didn't find what we want, we scan over them again
561 	 * making our way to the next node.  Still it's the easiest to
562 	 * implement approach; performance can come later. */
563 	for (offset = fdt_next_node(fdt, startoffset, NULL);
564 	     offset >= 0;
565 	     offset = fdt_next_node(fdt, offset, NULL)) {
566 		err = fdt_node_check_compatible(fdt, offset, compatible);
567 		if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
568 			return err;
569 		else if (err == 0)
570 			return offset;
571 	}
572 
573 	return offset; /* error from fdt_next_node() */
574 }
575