blob: 7b0777b67eb3cbb92609ae81366ef4bf66d1944b [file] [log] [blame]
Gerald Van Baren35748172007-03-31 12:00:56 -04001/*
2 * libfdt - Flat Device Tree manipulation
3 * Copyright (C) 2006 David Gibson, IBM Corporation.
Roger Meier35084762013-07-27 01:12:38 +02004 * SPDX-License-Identifier: GPL-2.0+ BSD-2-Clause
Gerald Van Baren35748172007-03-31 12:00:56 -04005 */
6#include "libfdt_env.h"
7
Bartlomiej Sieka8cf30802008-02-29 16:00:24 +01008#ifndef USE_HOSTCC
Gerald Van Baren35748172007-03-31 12:00:56 -04009#include <fdt.h>
10#include <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
22 if (! p)
23 /* 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
Kumar Gala8d04f022007-10-24 11:04:22 -050050int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
51{
David Gibsonfc7758e2008-07-09 14:10:24 +100052 FDT_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -050053 *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
54 *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
55 return 0;
56}
57
58int fdt_num_mem_rsv(const void *fdt)
59{
60 int i = 0;
61
62 while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
63 i++;
64 return i;
65}
66
David Gibsond1c63142010-03-09 17:39:14 +110067static int _nextprop(const void *fdt, int offset)
68{
69 uint32_t tag;
70 int nextoffset;
71
72 do {
73 tag = fdt_next_tag(fdt, offset, &nextoffset);
74
75 switch (tag) {
76 case FDT_END:
77 if (nextoffset >= 0)
78 return -FDT_ERR_BADSTRUCTURE;
79 else
80 return nextoffset;
81
82 case FDT_PROP:
83 return offset;
84 }
85 offset = nextoffset;
86 } while (tag == FDT_NOP);
87
88 return -FDT_ERR_NOTFOUND;
89}
90
David Gibsonae0b5902008-02-12 11:58:31 +110091int fdt_subnode_offset_namelen(const void *fdt, int offset,
Gerald Van Baren35748172007-03-31 12:00:56 -040092 const char *name, int namelen)
93{
David Gibson2c0b8432009-02-06 14:01:56 +110094 int depth;
Gerald Van Baren35748172007-03-31 12:00:56 -040095
David Gibsonfc7758e2008-07-09 14:10:24 +100096 FDT_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -040097
David Gibson2c0b8432009-02-06 14:01:56 +110098 for (depth = 0;
99 (offset >= 0) && (depth >= 0);
100 offset = fdt_next_node(fdt, offset, &depth))
101 if ((depth == 1)
102 && _fdt_nodename_eq(fdt, offset, name, namelen))
David Gibsonae0b5902008-02-12 11:58:31 +1100103 return offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400104
David Gibson2c0b8432009-02-06 14:01:56 +1100105 if (depth < 0)
David Gibson4bc7dee2008-10-29 23:27:45 -0500106 return -FDT_ERR_NOTFOUND;
David Gibson2c0b8432009-02-06 14:01:56 +1100107 return offset; /* error */
Gerald Van Baren35748172007-03-31 12:00:56 -0400108}
109
110int fdt_subnode_offset(const void *fdt, int parentoffset,
111 const char *name)
112{
113 return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
114}
115
Hans de Goede77d7fff2015-04-20 11:13:37 +0200116/*
117 * Find the next of path seperator, note we need to search for both '/' and ':'
118 * and then take the first one so that we do the rigth thing for e.g.
119 * "foo/bar:option" and "bar:option/otheroption", both of which happen, so
120 * first searching for either ':' or '/' does not work.
121 */
122static const char *fdt_path_next_seperator(const char *path)
123{
124 const char *sep1 = strchr(path, '/');
125 const char *sep2 = strchr(path, ':');
126
127 if (sep1 && sep2)
128 return (sep1 < sep2) ? sep1 : sep2;
129 else if (sep1)
130 return sep1;
131 else
132 return sep2;
133}
134
Kumar Gala8d04f022007-10-24 11:04:22 -0500135int fdt_path_offset(const void *fdt, const char *path)
Gerald Van Baren35748172007-03-31 12:00:56 -0400136{
137 const char *end = path + strlen(path);
138 const char *p = path;
139 int offset = 0;
140
David Gibsonfc7758e2008-07-09 14:10:24 +1000141 FDT_CHECK_HEADER(fdt);
Gerald Van Baren35748172007-03-31 12:00:56 -0400142
Kumar Galafeeca3f2008-08-14 08:28:19 -0500143 /* see if we have an alias */
144 if (*path != '/') {
Hans de Goede77d7fff2015-04-20 11:13:37 +0200145 const char *q = fdt_path_next_seperator(path);
Kumar Galafeeca3f2008-08-14 08:28:19 -0500146
Kumar Galafeeca3f2008-08-14 08:28:19 -0500147 if (!q)
148 q = end;
149
David Gibson9a6cf732008-08-20 16:55:14 +1000150 p = fdt_get_alias_namelen(fdt, p, q - p);
Kumar Galafeeca3f2008-08-14 08:28:19 -0500151 if (!p)
152 return -FDT_ERR_BADPATH;
153 offset = fdt_path_offset(fdt, p);
154
155 p = q;
156 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400157
158 while (*p) {
159 const char *q;
160
161 while (*p == '/')
162 p++;
Hans de Goede77d7fff2015-04-20 11:13:37 +0200163 if (*p == '\0' || *p == ':')
Kumar Gala8d04f022007-10-24 11:04:22 -0500164 return offset;
Hans de Goede77d7fff2015-04-20 11:13:37 +0200165 q = fdt_path_next_seperator(p);
Gerald Van Baren35748172007-03-31 12:00:56 -0400166 if (! q)
167 q = end;
168
169 offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
170 if (offset < 0)
171 return offset;
172
173 p = q;
174 }
175
Gerald Van Barenaea03c42007-03-31 14:30:53 -0400176 return offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400177}
178
Kumar Gala8d04f022007-10-24 11:04:22 -0500179const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
Gerald Van Baren35748172007-03-31 12:00:56 -0400180{
David Gibson2f08bfa2008-05-20 17:19:11 +1000181 const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);
Kumar Gala8d04f022007-10-24 11:04:22 -0500182 int err;
183
David Gibson2f08bfa2008-05-20 17:19:11 +1000184 if (((err = fdt_check_header(fdt)) != 0)
185 || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
186 goto fail;
Kumar Gala8d04f022007-10-24 11:04:22 -0500187
188 if (len)
189 *len = strlen(nh->name);
190
191 return nh->name;
192
193 fail:
194 if (len)
195 *len = err;
196 return NULL;
197}
198
David Gibsond1c63142010-03-09 17:39:14 +1100199int fdt_first_property_offset(const void *fdt, int nodeoffset)
200{
201 int offset;
202
203 if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
204 return offset;
205
206 return _nextprop(fdt, offset);
207}
208
209int fdt_next_property_offset(const void *fdt, int offset)
210{
211 if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)
212 return offset;
213
214 return _nextprop(fdt, offset);
215}
216
217const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
218 int offset,
219 int *lenp)
220{
221 int err;
222 const struct fdt_property *prop;
223
224 if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
225 if (lenp)
226 *lenp = err;
227 return NULL;
228 }
229
230 prop = _fdt_offset_ptr(fdt, offset);
231
232 if (lenp)
233 *lenp = fdt32_to_cpu(prop->len);
234
235 return prop;
236}
237
David Gibson02193992008-08-06 14:50:49 +1000238const struct fdt_property *fdt_get_property_namelen(const void *fdt,
David Gibsond1c63142010-03-09 17:39:14 +1100239 int offset,
David Gibson02193992008-08-06 14:50:49 +1000240 const char *name,
241 int namelen, int *lenp)
Kumar Gala8d04f022007-10-24 11:04:22 -0500242{
David Gibsond1c63142010-03-09 17:39:14 +1100243 for (offset = fdt_first_property_offset(fdt, offset);
244 (offset >= 0);
245 (offset = fdt_next_property_offset(fdt, offset))) {
246 const struct fdt_property *prop;
Gerald Van Baren35748172007-03-31 12:00:56 -0400247
David Gibsond1c63142010-03-09 17:39:14 +1100248 if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
249 offset = -FDT_ERR_INTERNAL;
Gerald Van Baren35748172007-03-31 12:00:56 -0400250 break;
Gerald Van Baren35748172007-03-31 12:00:56 -0400251 }
David Gibsond1c63142010-03-09 17:39:14 +1100252 if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
253 name, namelen))
254 return prop;
255 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400256
Gerald Van Baren35748172007-03-31 12:00:56 -0400257 if (lenp)
David Gibsond1c63142010-03-09 17:39:14 +1100258 *lenp = offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400259 return NULL;
260}
261
David Gibson02193992008-08-06 14:50:49 +1000262const struct fdt_property *fdt_get_property(const void *fdt,
263 int nodeoffset,
264 const char *name, int *lenp)
265{
266 return fdt_get_property_namelen(fdt, nodeoffset, name,
267 strlen(name), lenp);
268}
269
270const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
271 const char *name, int namelen, int *lenp)
Gerald Van Baren35748172007-03-31 12:00:56 -0400272{
273 const struct fdt_property *prop;
274
David Gibson02193992008-08-06 14:50:49 +1000275 prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
Gerald Van Baren35748172007-03-31 12:00:56 -0400276 if (! prop)
277 return NULL;
278
Kumar Gala8d04f022007-10-24 11:04:22 -0500279 return prop->data;
Gerald Van Baren35748172007-03-31 12:00:56 -0400280}
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400281
David Gibsond1c63142010-03-09 17:39:14 +1100282const void *fdt_getprop_by_offset(const void *fdt, int offset,
283 const char **namep, int *lenp)
284{
285 const struct fdt_property *prop;
286
287 prop = fdt_get_property_by_offset(fdt, offset, lenp);
288 if (!prop)
289 return NULL;
290 if (namep)
291 *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
292 return prop->data;
293}
294
David Gibson02193992008-08-06 14:50:49 +1000295const void *fdt_getprop(const void *fdt, int nodeoffset,
296 const char *name, int *lenp)
297{
298 return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
299}
300
Kumar Gala8d04f022007-10-24 11:04:22 -0500301uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400302{
Kim Phillipsb2ba62a2013-01-16 13:59:50 +0000303 const fdt32_t *php;
Kumar Gala8d04f022007-10-24 11:04:22 -0500304 int len;
305
David Gibson05a22ba2009-11-26 15:37:13 +1100306 /* FIXME: This is a bit sub-optimal, since we potentially scan
307 * over all the properties twice. */
308 php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
309 if (!php || (len != sizeof(*php))) {
310 php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
311 if (!php || (len != sizeof(*php)))
312 return 0;
313 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500314
315 return fdt32_to_cpu(*php);
316}
317
David Gibson9a6cf732008-08-20 16:55:14 +1000318const char *fdt_get_alias_namelen(const void *fdt,
319 const char *name, int namelen)
320{
321 int aliasoffset;
322
323 aliasoffset = fdt_path_offset(fdt, "/aliases");
324 if (aliasoffset < 0)
325 return NULL;
326
327 return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
328}
329
330const char *fdt_get_alias(const void *fdt, const char *name)
331{
332 return fdt_get_alias_namelen(fdt, name, strlen(name));
333}
334
Kumar Gala8d04f022007-10-24 11:04:22 -0500335int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
336{
David Gibsonae0b5902008-02-12 11:58:31 +1100337 int pdepth = 0, p = 0;
338 int offset, depth, namelen;
Kumar Gala8d04f022007-10-24 11:04:22 -0500339 const char *name;
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400340
David Gibsonfc7758e2008-07-09 14:10:24 +1000341 FDT_CHECK_HEADER(fdt);
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400342
Kumar Gala8d04f022007-10-24 11:04:22 -0500343 if (buflen < 2)
Gerald Van Baren3f9f08c2007-04-14 22:46:41 -0400344 return -FDT_ERR_NOSPACE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500345
David Gibsonae0b5902008-02-12 11:58:31 +1100346 for (offset = 0, depth = 0;
347 (offset >= 0) && (offset <= nodeoffset);
348 offset = fdt_next_node(fdt, offset, &depth)) {
David Gibsonae0b5902008-02-12 11:58:31 +1100349 while (pdepth > depth) {
350 do {
351 p--;
352 } while (buf[p-1] != '/');
353 pdepth--;
354 }
355
David Gibsonbbdbc7c2008-08-29 14:19:13 +1000356 if (pdepth >= depth) {
357 name = fdt_get_name(fdt, offset, &namelen);
358 if (!name)
359 return namelen;
360 if ((p + namelen + 1) <= buflen) {
361 memcpy(buf + p, name, namelen);
362 p += namelen;
363 buf[p++] = '/';
364 pdepth++;
365 }
David Gibsonae0b5902008-02-12 11:58:31 +1100366 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500367
David Gibsonae0b5902008-02-12 11:58:31 +1100368 if (offset == nodeoffset) {
369 if (pdepth < (depth + 1))
370 return -FDT_ERR_NOSPACE;
371
372 if (p > 1) /* special case so that root path is "/", not "" */
Kumar Gala8d04f022007-10-24 11:04:22 -0500373 p--;
David Gibsonae0b5902008-02-12 11:58:31 +1100374 buf[p] = '\0';
David Gibsonbbdbc7c2008-08-29 14:19:13 +1000375 return 0;
Kumar Gala8d04f022007-10-24 11:04:22 -0500376 }
377 }
378
David Gibsonae0b5902008-02-12 11:58:31 +1100379 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
380 return -FDT_ERR_BADOFFSET;
381 else if (offset == -FDT_ERR_BADOFFSET)
382 return -FDT_ERR_BADSTRUCTURE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500383
David Gibsonae0b5902008-02-12 11:58:31 +1100384 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500385}
386
387int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
388 int supernodedepth, int *nodedepth)
389{
David Gibsonae0b5902008-02-12 11:58:31 +1100390 int offset, depth;
Kumar Gala8d04f022007-10-24 11:04:22 -0500391 int supernodeoffset = -FDT_ERR_INTERNAL;
392
David Gibsonfc7758e2008-07-09 14:10:24 +1000393 FDT_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500394
395 if (supernodedepth < 0)
396 return -FDT_ERR_NOTFOUND;
397
David Gibsonae0b5902008-02-12 11:58:31 +1100398 for (offset = 0, depth = 0;
399 (offset >= 0) && (offset <= nodeoffset);
400 offset = fdt_next_node(fdt, offset, &depth)) {
401 if (depth == supernodedepth)
402 supernodeoffset = offset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500403
David Gibsonae0b5902008-02-12 11:58:31 +1100404 if (offset == nodeoffset) {
405 if (nodedepth)
406 *nodedepth = depth;
Kumar Gala8d04f022007-10-24 11:04:22 -0500407
David Gibsonae0b5902008-02-12 11:58:31 +1100408 if (supernodedepth > depth)
409 return -FDT_ERR_NOTFOUND;
410 else
411 return supernodeoffset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500412 }
David Gibsonae0b5902008-02-12 11:58:31 +1100413 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500414
David Gibsonae0b5902008-02-12 11:58:31 +1100415 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
416 return -FDT_ERR_BADOFFSET;
417 else if (offset == -FDT_ERR_BADOFFSET)
418 return -FDT_ERR_BADSTRUCTURE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500419
David Gibsonae0b5902008-02-12 11:58:31 +1100420 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500421}
422
423int fdt_node_depth(const void *fdt, int nodeoffset)
424{
425 int nodedepth;
426 int err;
427
428 err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
429 if (err)
430 return (err < 0) ? err : -FDT_ERR_INTERNAL;
431 return nodedepth;
432}
433
434int fdt_parent_offset(const void *fdt, int nodeoffset)
435{
436 int nodedepth = fdt_node_depth(fdt, nodeoffset);
437
438 if (nodedepth < 0)
439 return nodedepth;
440 return fdt_supernode_atdepth_offset(fdt, nodeoffset,
441 nodedepth - 1, NULL);
442}
443
444int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
445 const char *propname,
446 const void *propval, int proplen)
447{
David Gibsonae0b5902008-02-12 11:58:31 +1100448 int offset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500449 const void *val;
450 int len;
451
David Gibsonfc7758e2008-07-09 14:10:24 +1000452 FDT_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500453
Kumar Gala8d04f022007-10-24 11:04:22 -0500454 /* FIXME: The algorithm here is pretty horrible: we scan each
455 * property of a node in fdt_getprop(), then if that didn't
456 * find what we want, we scan over them again making our way
457 * to the next node. Still it's the easiest to implement
458 * approach; performance can come later. */
David Gibsonae0b5902008-02-12 11:58:31 +1100459 for (offset = fdt_next_node(fdt, startoffset, NULL);
460 offset >= 0;
461 offset = fdt_next_node(fdt, offset, NULL)) {
462 val = fdt_getprop(fdt, offset, propname, &len);
463 if (val && (len == proplen)
464 && (memcmp(val, propval, len) == 0))
465 return offset;
466 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500467
David Gibsonae0b5902008-02-12 11:58:31 +1100468 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500469}
470
471int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
472{
David Gibson05a22ba2009-11-26 15:37:13 +1100473 int offset;
474
Kumar Gala8d04f022007-10-24 11:04:22 -0500475 if ((phandle == 0) || (phandle == -1))
476 return -FDT_ERR_BADPHANDLE;
David Gibson05a22ba2009-11-26 15:37:13 +1100477
478 FDT_CHECK_HEADER(fdt);
479
480 /* FIXME: The algorithm here is pretty horrible: we
481 * potentially scan each property of a node in
482 * fdt_get_phandle(), then if that didn't find what
483 * we want, we scan over them again making our way to the next
484 * node. Still it's the easiest to implement approach;
485 * performance can come later. */
486 for (offset = fdt_next_node(fdt, -1, NULL);
487 offset >= 0;
488 offset = fdt_next_node(fdt, offset, NULL)) {
489 if (fdt_get_phandle(fdt, offset) == phandle)
490 return offset;
491 }
492
493 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500494}
495
Simon Glasse853b322013-01-21 12:59:18 -0800496int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
Kumar Gala8d04f022007-10-24 11:04:22 -0500497{
498 int len = strlen(str);
David Gibsonef4e8ce2008-07-07 10:10:48 +1000499 const char *p;
Kumar Gala8d04f022007-10-24 11:04:22 -0500500
501 while (listlen >= len) {
502 if (memcmp(str, strlist, len+1) == 0)
503 return 1;
504 p = memchr(strlist, '\0', listlen);
505 if (!p)
506 return 0; /* malformed strlist.. */
507 listlen -= (p-strlist) + 1;
508 strlist = p + 1;
Gerald Van Baren3f9f08c2007-04-14 22:46:41 -0400509 }
510 return 0;
511}
Kumar Gala8d04f022007-10-24 11:04:22 -0500512
Thierry Redingbc4147a2014-08-26 17:33:50 +0200513int fdt_count_strings(const void *fdt, int node, const char *property)
514{
515 int length, i, count = 0;
516 const char *list;
517
518 list = fdt_getprop(fdt, node, property, &length);
519 if (!list)
Masahiro Yamada73e1e792015-07-15 01:08:44 +0900520 return length;
Thierry Redingbc4147a2014-08-26 17:33:50 +0200521
522 for (i = 0; i < length; i++) {
523 int len = strlen(list);
524
525 list += len + 1;
526 i += len;
527 count++;
528 }
529
530 return count;
531}
532
Thierry Redingfc503c12014-08-26 17:33:51 +0200533int fdt_find_string(const void *fdt, int node, const char *property,
534 const char *string)
535{
536 const char *list, *end;
537 int len, index = 0;
538
539 list = fdt_getprop(fdt, node, property, &len);
540 if (!list)
541 return len;
542
543 end = list + len;
544 len = strlen(string);
545
546 while (list < end) {
547 int l = strlen(list);
548
549 if (l == len && memcmp(list, string, len) == 0)
550 return index;
551
552 list += l + 1;
553 index++;
554 }
555
556 return -FDT_ERR_NOTFOUND;
557}
558
Thierry Reding5094eb42014-08-26 17:33:52 +0200559int fdt_get_string_index(const void *fdt, int node, const char *property,
560 int index, const char **output)
561{
562 const char *list;
563 int length, i;
564
565 list = fdt_getprop(fdt, node, property, &length);
566
567 for (i = 0; i < length; i++) {
568 int len = strlen(list);
569
570 if (index == 0) {
571 *output = list;
572 return 0;
573 }
574
575 list += len + 1;
576 i += len;
577 index--;
578 }
579
Masahiro Yamada31f334a2015-07-15 01:08:43 +0900580 return -FDT_ERR_NOTFOUND;
Thierry Reding5094eb42014-08-26 17:33:52 +0200581}
582
583int fdt_get_string(const void *fdt, int node, const char *property,
584 const char **output)
585{
586 return fdt_get_string_index(fdt, node, property, 0, output);
587}
588
Kumar Gala8d04f022007-10-24 11:04:22 -0500589int fdt_node_check_compatible(const void *fdt, int nodeoffset,
590 const char *compatible)
591{
592 const void *prop;
593 int len;
594
595 prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
596 if (!prop)
597 return len;
Simon Glasse853b322013-01-21 12:59:18 -0800598 if (fdt_stringlist_contains(prop, len, compatible))
Kumar Gala8d04f022007-10-24 11:04:22 -0500599 return 0;
600 else
601 return 1;
602}
603
604int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
605 const char *compatible)
606{
David Gibson11abe452008-02-18 18:09:04 +1100607 int offset, err;
Kumar Gala8d04f022007-10-24 11:04:22 -0500608
David Gibsonfc7758e2008-07-09 14:10:24 +1000609 FDT_CHECK_HEADER(fdt);
Kumar Gala8d04f022007-10-24 11:04:22 -0500610
Kumar Gala8d04f022007-10-24 11:04:22 -0500611 /* FIXME: The algorithm here is pretty horrible: we scan each
612 * property of a node in fdt_node_check_compatible(), then if
613 * that didn't find what we want, we scan over them again
614 * making our way to the next node. Still it's the easiest to
615 * implement approach; performance can come later. */
David Gibsonae0b5902008-02-12 11:58:31 +1100616 for (offset = fdt_next_node(fdt, startoffset, NULL);
617 offset >= 0;
618 offset = fdt_next_node(fdt, offset, NULL)) {
619 err = fdt_node_check_compatible(fdt, offset, compatible);
620 if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
621 return err;
622 else if (err == 0)
623 return offset;
624 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500625
David Gibsonae0b5902008-02-12 11:58:31 +1100626 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500627}