blob: b6ca4e0b0c308fb9f5ebb9dfe5639aaa90769f8c [file] [log] [blame]
Tom Rini4549e782018-05-06 18:27:01 -04001// SPDX-License-Identifier: GPL-2.0+ OR BSD-2-Clause
Gerald Van Baren35748172007-03-31 12:00:56 -04002/*
3 * libfdt - Flat Device Tree manipulation
4 * Copyright (C) 2006 David Gibson, IBM Corporation.
Gerald Van Baren35748172007-03-31 12:00:56 -04005 */
Masahiro Yamadab08c8c42018-03-05 01:20:11 +09006#include <linux/libfdt_env.h>
Gerald Van Baren35748172007-03-31 12:00:56 -04007
Bartlomiej Sieka8cf30802008-02-29 16:00:24 +01008#ifndef USE_HOSTCC
Gerald Van Baren35748172007-03-31 12:00:56 -04009#include <fdt.h>
Masahiro Yamadab08c8c42018-03-05 01:20:11 +090010#include <linux/libfdt.h>
Bartlomiej Sieka8cf30802008-02-29 16:00:24 +010011#else
12#include "fdt_host.h"
13#endif
Gerald Van Baren35748172007-03-31 12:00:56 -040014
15#include "libfdt_internal.h"
16
David Gibsonfc7758e2008-07-09 14:10:24 +100017static int _fdt_nodename_eq(const void *fdt, int offset,
18 const char *s, int len)
Gerald Van Baren35748172007-03-31 12:00:56 -040019{
David Gibsonae0b5902008-02-12 11:58:31 +110020 const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
Gerald Van Baren35748172007-03-31 12:00:56 -040021
Robert P. J. Day6feed2a2016-05-23 05:40:55 -040022 if (!p)
Gerald Van Baren35748172007-03-31 12:00:56 -040023 /* short match */
24 return 0;
25
26 if (memcmp(p, s, len) != 0)
27 return 0;
28
Kumar Gala8d04f022007-10-24 11:04:22 -050029 if (p[len] == '\0')
30 return 1;
31 else if (!memchr(s, '@', len) && (p[len] == '@'))
32 return 1;
33 else
Gerald Van Baren35748172007-03-31 12:00:56 -040034 return 0;
Gerald Van Baren35748172007-03-31 12:00:56 -040035}
36
Kumar Gala8d04f022007-10-24 11:04:22 -050037const char *fdt_string(const void *fdt, int stroffset)
Gerald Van Baren35748172007-03-31 12:00:56 -040038{
David Gibsonc6683022008-07-07 10:14:15 +100039 return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
Gerald Van Baren35748172007-03-31 12:00:56 -040040}
41
David Gibson02193992008-08-06 14:50:49 +100042static 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
Jon Nalleyaf67b252014-02-26 11:32:21 -050047 return (strnlen(p, len + 1) == len) && (memcmp(p, s, len) == 0);
David Gibson02193992008-08-06 14:50:49 +100048}
49
Maxime Ripard57c78092016-07-05 10:26:39 +020050uint32_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)
Simon Glass9c07b982016-10-02 17:59:27 -060063 return (uint32_t)-1;
Maxime Ripard57c78092016-07-05 10:26:39 +020064
65 phandle = fdt_get_phandle(fdt, offset);
66 if (phandle == (uint32_t)-1)
Simon Glass9c07b982016-10-02 17:59:27 -060067 continue;
Maxime Ripard57c78092016-07-05 10:26:39 +020068
69 if (phandle > max_phandle)
70 max_phandle = phandle;
71 }
72
73 return 0;
74}
75
Kumar Gala8d04f022007-10-24 11:04:22 -050076int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
77{
David Gibsonfc7758e2008-07-09 14:10:24 +100078 FDT_CHECK_HEADER(fdt);
Rob Herringdb405d12018-05-19 14:13:53 +020079 *address = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->address);
80 *size = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->size);
Kumar Gala8d04f022007-10-24 11:04:22 -050081 return 0;
82}
83
84int fdt_num_mem_rsv(const void *fdt)
85{
86 int i = 0;
87
Rob Herringdb405d12018-05-19 14:13:53 +020088 while (fdt64_to_cpu(fdt_mem_rsv_(fdt, i)->size) != 0)
Kumar Gala8d04f022007-10-24 11:04:22 -050089 i++;
90 return i;
91}
92
David Gibsond1c63142010-03-09 17:39:14 +110093static 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
David Gibsonae0b5902008-02-12 11:58:31 +1100117int fdt_subnode_offset_namelen(const void *fdt, int offset,
Gerald Van Baren35748172007-03-31 12:00:56 -0400118 const char *name, int namelen)
119{
David Gibson2c0b8432009-02-06 14:01:56 +1100120 int depth;
Gerald Van Baren35748172007-03-31 12:00:56 -0400121
David Gibsonfc7758e2008-07-09 14:10:24 +1000122 FDT_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400123
David Gibson2c0b8432009-02-06 14:01:56 +1100124 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))
David Gibsonae0b5902008-02-12 11:58:31 +1100129 return offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400130
David Gibson2c0b8432009-02-06 14:01:56 +1100131 if (depth < 0)
David Gibson4bc7dee2008-10-29 23:27:45 -0500132 return -FDT_ERR_NOTFOUND;
David Gibson2c0b8432009-02-06 14:01:56 +1100133 return offset; /* error */
Gerald Van Baren35748172007-03-31 12:00:56 -0400134}
135
136int 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
Hans de Goede77d7fff2015-04-20 11:13:37 +0200142/*
Maxime Ripard6f5f92c2016-07-05 10:26:40 +0200143 * Find the next of path separator, note we need to search for both '/' and ':'
Robert P. J. Day6feed2a2016-05-23 05:40:55 -0400144 * and then take the first one so that we do the right thing for e.g.
Hans de Goede77d7fff2015-04-20 11:13:37 +0200145 * "foo/bar:option" and "bar:option/otheroption", both of which happen, so
146 * first searching for either ':' or '/' does not work.
147 */
Maxime Ripard8e968572016-07-05 10:26:41 +0200148static const char *fdt_path_next_separator(const char *path, int len)
Hans de Goede77d7fff2015-04-20 11:13:37 +0200149{
Maxime Ripard8e968572016-07-05 10:26:41 +0200150 const void *sep1 = memchr(path, '/', len);
151 const void *sep2 = memchr(path, ':', len);
Hans de Goede77d7fff2015-04-20 11:13:37 +0200152
153 if (sep1 && sep2)
154 return (sep1 < sep2) ? sep1 : sep2;
155 else if (sep1)
156 return sep1;
157 else
158 return sep2;
159}
160
Maxime Ripard8e968572016-07-05 10:26:41 +0200161int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
Gerald Van Baren35748172007-03-31 12:00:56 -0400162{
Maxime Ripard8e968572016-07-05 10:26:41 +0200163 const char *end = path + namelen;
Gerald Van Baren35748172007-03-31 12:00:56 -0400164 const char *p = path;
165 int offset = 0;
166
David Gibsonfc7758e2008-07-09 14:10:24 +1000167 FDT_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400168
Kumar Galafeeca3f2008-08-14 08:28:19 -0500169 /* see if we have an alias */
170 if (*path != '/') {
Maxime Ripard8e968572016-07-05 10:26:41 +0200171 const char *q = fdt_path_next_separator(path, namelen);
Kumar Galafeeca3f2008-08-14 08:28:19 -0500172
Kumar Galafeeca3f2008-08-14 08:28:19 -0500173 if (!q)
174 q = end;
175
David Gibson9a6cf732008-08-20 16:55:14 +1000176 p = fdt_get_alias_namelen(fdt, p, q - p);
Kumar Galafeeca3f2008-08-14 08:28:19 -0500177 if (!p)
178 return -FDT_ERR_BADPATH;
179 offset = fdt_path_offset(fdt, p);
180
181 p = q;
182 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400183
Maxime Ripard8e968572016-07-05 10:26:41 +0200184 while (*p && (p < end)) {
Gerald Van Baren35748172007-03-31 12:00:56 -0400185 const char *q;
186
187 while (*p == '/')
188 p++;
Maxime Ripard8e968572016-07-05 10:26:41 +0200189
Hans de Goede77d7fff2015-04-20 11:13:37 +0200190 if (*p == '\0' || *p == ':')
Kumar Gala8d04f022007-10-24 11:04:22 -0500191 return offset;
Maxime Ripard8e968572016-07-05 10:26:41 +0200192
193 q = fdt_path_next_separator(p, end - p);
Robert P. J. Day6feed2a2016-05-23 05:40:55 -0400194 if (!q)
Gerald Van Baren35748172007-03-31 12:00:56 -0400195 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
Gerald Van Barenaea03c42007-03-31 14:30:53 -0400204 return offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400205}
206
Simon Glass42b76002016-10-02 17:59:30 -0600207int fdt_path_offset(const void *fdt, const char *path)
208{
209 return fdt_path_offset_namelen(fdt, path, strlen(path));
210}
211
Kumar Gala8d04f022007-10-24 11:04:22 -0500212const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
Gerald Van Baren35748172007-03-31 12:00:56 -0400213{
Rob Herringdb405d12018-05-19 14:13:53 +0200214 const struct fdt_node_header *nh = fdt_offset_ptr_(fdt, nodeoffset);
Kumar Gala8d04f022007-10-24 11:04:22 -0500215 int err;
216
David Gibson2f08bfa2008-05-20 17:19:11 +1000217 if (((err = fdt_check_header(fdt)) != 0)
Rob Herringdb405d12018-05-19 14:13:53 +0200218 || ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
David Gibson2f08bfa2008-05-20 17:19:11 +1000219 goto fail;
Kumar Gala8d04f022007-10-24 11:04:22 -0500220
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
David Gibsond1c63142010-03-09 17:39:14 +1100232int fdt_first_property_offset(const void *fdt, int nodeoffset)
233{
234 int offset;
235
Rob Herringdb405d12018-05-19 14:13:53 +0200236 if ((offset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
David Gibsond1c63142010-03-09 17:39:14 +1100237 return offset;
238
239 return _nextprop(fdt, offset);
240}
241
242int fdt_next_property_offset(const void *fdt, int offset)
243{
Rob Herringdb405d12018-05-19 14:13:53 +0200244 if ((offset = fdt_check_prop_offset_(fdt, offset)) < 0)
David Gibsond1c63142010-03-09 17:39:14 +1100245 return offset;
246
247 return _nextprop(fdt, offset);
248}
249
250const 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
Rob Herringdb405d12018-05-19 14:13:53 +0200257 if ((err = fdt_check_prop_offset_(fdt, offset)) < 0) {
David Gibsond1c63142010-03-09 17:39:14 +1100258 if (lenp)
259 *lenp = err;
260 return NULL;
261 }
262
Rob Herringdb405d12018-05-19 14:13:53 +0200263 prop = fdt_offset_ptr_(fdt, offset);
David Gibsond1c63142010-03-09 17:39:14 +1100264
265 if (lenp)
266 *lenp = fdt32_to_cpu(prop->len);
267
268 return prop;
269}
270
David Gibson02193992008-08-06 14:50:49 +1000271const struct fdt_property *fdt_get_property_namelen(const void *fdt,
David Gibsond1c63142010-03-09 17:39:14 +1100272 int offset,
David Gibson02193992008-08-06 14:50:49 +1000273 const char *name,
274 int namelen, int *lenp)
Kumar Gala8d04f022007-10-24 11:04:22 -0500275{
David Gibsond1c63142010-03-09 17:39:14 +1100276 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;
Gerald Van Baren35748172007-03-31 12:00:56 -0400280
David Gibsond1c63142010-03-09 17:39:14 +1100281 if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
282 offset = -FDT_ERR_INTERNAL;
Gerald Van Baren35748172007-03-31 12:00:56 -0400283 break;
Gerald Van Baren35748172007-03-31 12:00:56 -0400284 }
David Gibsond1c63142010-03-09 17:39:14 +1100285 if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
286 name, namelen))
287 return prop;
288 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400289
Gerald Van Baren35748172007-03-31 12:00:56 -0400290 if (lenp)
David Gibsond1c63142010-03-09 17:39:14 +1100291 *lenp = offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400292 return NULL;
293}
294
David Gibson02193992008-08-06 14:50:49 +1000295const 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
303const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
304 const char *name, int namelen, int *lenp)
Gerald Van Baren35748172007-03-31 12:00:56 -0400305{
306 const struct fdt_property *prop;
307
David Gibson02193992008-08-06 14:50:49 +1000308 prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
Robert P. J. Day6feed2a2016-05-23 05:40:55 -0400309 if (!prop)
Gerald Van Baren35748172007-03-31 12:00:56 -0400310 return NULL;
311
Kumar Gala8d04f022007-10-24 11:04:22 -0500312 return prop->data;
Gerald Van Baren35748172007-03-31 12:00:56 -0400313}
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400314
David Gibsond1c63142010-03-09 17:39:14 +1100315const 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
David Gibson02193992008-08-06 14:50:49 +1000328const 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
Kumar Gala8d04f022007-10-24 11:04:22 -0500334uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400335{
Kim Phillipsb2ba62a2013-01-16 13:59:50 +0000336 const fdt32_t *php;
Kumar Gala8d04f022007-10-24 11:04:22 -0500337 int len;
338
David Gibson05a22ba2009-11-26 15:37:13 +1100339 /* 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 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500347
348 return fdt32_to_cpu(*php);
349}
350
David Gibson9a6cf732008-08-20 16:55:14 +1000351const 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
363const char *fdt_get_alias(const void *fdt, const char *name)
364{
365 return fdt_get_alias_namelen(fdt, name, strlen(name));
366}
367
Kumar Gala8d04f022007-10-24 11:04:22 -0500368int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
369{
David Gibsonae0b5902008-02-12 11:58:31 +1100370 int pdepth = 0, p = 0;
371 int offset, depth, namelen;
Kumar Gala8d04f022007-10-24 11:04:22 -0500372 const char *name;
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400373
David Gibsonfc7758e2008-07-09 14:10:24 +1000374 FDT_CHECK_HEADER(fdt);
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400375
Kumar Gala8d04f022007-10-24 11:04:22 -0500376 if (buflen < 2)
Gerald Van Baren3f9f08c2007-04-14 22:46:41 -0400377 return -FDT_ERR_NOSPACE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500378
David Gibsonae0b5902008-02-12 11:58:31 +1100379 for (offset = 0, depth = 0;
380 (offset >= 0) && (offset <= nodeoffset);
381 offset = fdt_next_node(fdt, offset, &depth)) {
David Gibsonae0b5902008-02-12 11:58:31 +1100382 while (pdepth > depth) {
383 do {
384 p--;
385 } while (buf[p-1] != '/');
386 pdepth--;
387 }
388
David Gibsonbbdbc7c2008-08-29 14:19:13 +1000389 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 }
David Gibsonae0b5902008-02-12 11:58:31 +1100399 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500400
David Gibsonae0b5902008-02-12 11:58:31 +1100401 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 "" */
Kumar Gala8d04f022007-10-24 11:04:22 -0500406 p--;
David Gibsonae0b5902008-02-12 11:58:31 +1100407 buf[p] = '\0';
David Gibsonbbdbc7c2008-08-29 14:19:13 +1000408 return 0;
Kumar Gala8d04f022007-10-24 11:04:22 -0500409 }
410 }
411
David Gibsonae0b5902008-02-12 11:58:31 +1100412 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
413 return -FDT_ERR_BADOFFSET;
414 else if (offset == -FDT_ERR_BADOFFSET)
415 return -FDT_ERR_BADSTRUCTURE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500416
David Gibsonae0b5902008-02-12 11:58:31 +1100417 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500418}
419
420int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
421 int supernodedepth, int *nodedepth)
422{
David Gibsonae0b5902008-02-12 11:58:31 +1100423 int offset, depth;
Kumar Gala8d04f022007-10-24 11:04:22 -0500424 int supernodeoffset = -FDT_ERR_INTERNAL;
425
David Gibsonfc7758e2008-07-09 14:10:24 +1000426 FDT_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500427
428 if (supernodedepth < 0)
429 return -FDT_ERR_NOTFOUND;
430
David Gibsonae0b5902008-02-12 11:58:31 +1100431 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;
Kumar Gala8d04f022007-10-24 11:04:22 -0500436
David Gibsonae0b5902008-02-12 11:58:31 +1100437 if (offset == nodeoffset) {
438 if (nodedepth)
439 *nodedepth = depth;
Kumar Gala8d04f022007-10-24 11:04:22 -0500440
David Gibsonae0b5902008-02-12 11:58:31 +1100441 if (supernodedepth > depth)
442 return -FDT_ERR_NOTFOUND;
443 else
444 return supernodeoffset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500445 }
David Gibsonae0b5902008-02-12 11:58:31 +1100446 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500447
David Gibsonae0b5902008-02-12 11:58:31 +1100448 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
449 return -FDT_ERR_BADOFFSET;
450 else if (offset == -FDT_ERR_BADOFFSET)
451 return -FDT_ERR_BADSTRUCTURE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500452
David Gibsonae0b5902008-02-12 11:58:31 +1100453 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500454}
455
456int 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
467int 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
477int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
478 const char *propname,
479 const void *propval, int proplen)
480{
David Gibsonae0b5902008-02-12 11:58:31 +1100481 int offset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500482 const void *val;
483 int len;
484
David Gibsonfc7758e2008-07-09 14:10:24 +1000485 FDT_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500486
Kumar Gala8d04f022007-10-24 11:04:22 -0500487 /* 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. */
David Gibsonae0b5902008-02-12 11:58:31 +1100492 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 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500500
David Gibsonae0b5902008-02-12 11:58:31 +1100501 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500502}
503
504int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
505{
David Gibson05a22ba2009-11-26 15:37:13 +1100506 int offset;
507
Kumar Gala8d04f022007-10-24 11:04:22 -0500508 if ((phandle == 0) || (phandle == -1))
509 return -FDT_ERR_BADPHANDLE;
David Gibson05a22ba2009-11-26 15:37:13 +1100510
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() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500527}
528
Simon Glasse853b322013-01-21 12:59:18 -0800529int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
Kumar Gala8d04f022007-10-24 11:04:22 -0500530{
531 int len = strlen(str);
David Gibsonef4e8ce2008-07-07 10:10:48 +1000532 const char *p;
Kumar Gala8d04f022007-10-24 11:04:22 -0500533
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;
Gerald Van Baren3f9f08c2007-04-14 22:46:41 -0400542 }
543 return 0;
544}
Kumar Gala8d04f022007-10-24 11:04:22 -0500545
Simon Glassb02e4042016-10-02 17:59:28 -0600546int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
Thierry Redingbc4147a2014-08-26 17:33:50 +0200547{
Simon Glassb02e4042016-10-02 17:59:28 -0600548 const char *list, *end;
549 int length, count = 0;
Thierry Redingbc4147a2014-08-26 17:33:50 +0200550
Simon Glassb02e4042016-10-02 17:59:28 -0600551 list = fdt_getprop(fdt, nodeoffset, property, &length);
Thierry Redingbc4147a2014-08-26 17:33:50 +0200552 if (!list)
Masahiro Yamada7c9786d2016-10-17 20:22:33 +0900553 return length;
Thierry Redingbc4147a2014-08-26 17:33:50 +0200554
Simon Glassb02e4042016-10-02 17:59:28 -0600555 end = list + length;
Thierry Redingbc4147a2014-08-26 17:33:50 +0200556
Simon Glassb02e4042016-10-02 17:59:28 -0600557 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;
Thierry Redingbc4147a2014-08-26 17:33:50 +0200565 count++;
566 }
567
568 return count;
569}
570
Simon Glassb02e4042016-10-02 17:59:28 -0600571int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
572 const char *string)
Thierry Redingfc503c12014-08-26 17:33:51 +0200573{
Simon Glassb02e4042016-10-02 17:59:28 -0600574 int length, len, idx = 0;
Thierry Redingfc503c12014-08-26 17:33:51 +0200575 const char *list, *end;
Thierry Redingfc503c12014-08-26 17:33:51 +0200576
Simon Glassb02e4042016-10-02 17:59:28 -0600577 list = fdt_getprop(fdt, nodeoffset, property, &length);
Thierry Redingfc503c12014-08-26 17:33:51 +0200578 if (!list)
Masahiro Yamada01ae56c2016-10-17 20:22:34 +0900579 return length;
Thierry Redingfc503c12014-08-26 17:33:51 +0200580
Simon Glassb02e4042016-10-02 17:59:28 -0600581 len = strlen(string) + 1;
582 end = list + length;
Thierry Redingfc503c12014-08-26 17:33:51 +0200583
584 while (list < end) {
Simon Glassb02e4042016-10-02 17:59:28 -0600585 length = strnlen(list, end - list) + 1;
Thierry Redingfc503c12014-08-26 17:33:51 +0200586
Simon Glassb02e4042016-10-02 17:59:28 -0600587 /* Abort if the last string isn't properly NUL-terminated. */
588 if (list + length > end)
589 return -FDT_ERR_BADVALUE;
Thierry Redingfc503c12014-08-26 17:33:51 +0200590
Simon Glassb02e4042016-10-02 17:59:28 -0600591 if (length == len && memcmp(list, string, length) == 0)
592 return idx;
593
594 list += length;
595 idx++;
Thierry Redingfc503c12014-08-26 17:33:51 +0200596 }
597
598 return -FDT_ERR_NOTFOUND;
599}
600
Simon Glassb02e4042016-10-02 17:59:28 -0600601const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
602 const char *property, int idx,
603 int *lenp)
Thierry Reding5094eb42014-08-26 17:33:52 +0200604{
Simon Glassb02e4042016-10-02 17:59:28 -0600605 const char *list, *end;
606 int length;
Thierry Reding5094eb42014-08-26 17:33:52 +0200607
Simon Glassb02e4042016-10-02 17:59:28 -0600608 list = fdt_getprop(fdt, nodeoffset, property, &length);
609 if (!list) {
610 if (lenp)
611 *lenp = length;
Thierry Reding5094eb42014-08-26 17:33:52 +0200612
Simon Glassb02e4042016-10-02 17:59:28 -0600613 return NULL;
614 }
Thierry Reding5094eb42014-08-26 17:33:52 +0200615
Simon Glassb02e4042016-10-02 17:59:28 -0600616 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;
Thierry Reding5094eb42014-08-26 17:33:52 +0200627 }
628
Simon Glassb02e4042016-10-02 17:59:28 -0600629 if (idx == 0) {
630 if (lenp)
631 *lenp = length - 1;
632
633 return list;
634 }
635
636 list += length;
637 idx--;
Thierry Reding5094eb42014-08-26 17:33:52 +0200638 }
639
Simon Glassb02e4042016-10-02 17:59:28 -0600640 if (lenp)
641 *lenp = -FDT_ERR_NOTFOUND;
Thierry Reding5094eb42014-08-26 17:33:52 +0200642
Simon Glassb02e4042016-10-02 17:59:28 -0600643 return NULL;
Thierry Reding5094eb42014-08-26 17:33:52 +0200644}
645
Kumar Gala8d04f022007-10-24 11:04:22 -0500646int 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;
Simon Glass9c07b982016-10-02 17:59:27 -0600655
656 return !fdt_stringlist_contains(prop, len, compatible);
Kumar Gala8d04f022007-10-24 11:04:22 -0500657}
658
659int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
660 const char *compatible)
661{
David Gibson11abe452008-02-18 18:09:04 +1100662 int offset, err;
Kumar Gala8d04f022007-10-24 11:04:22 -0500663
David Gibsonfc7758e2008-07-09 14:10:24 +1000664 FDT_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500665
Kumar Gala8d04f022007-10-24 11:04:22 -0500666 /* 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. */
David Gibsonae0b5902008-02-12 11:58:31 +1100671 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 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500680
David Gibsonae0b5902008-02-12 11:58:31 +1100681 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500682}