blob: 11d80d2fa249d8a6085888e48b44130d6f7ca531 [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.
4 *
Kumar Gala8d04f022007-10-24 11:04:22 -05005 * libfdt is dual licensed: you can use it either under the terms of
6 * the GPL, or the BSD license, at your option.
Gerald Van Baren35748172007-03-31 12:00:56 -04007 *
Kumar Gala8d04f022007-10-24 11:04:22 -05008 * 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.
Gerald Van Baren35748172007-03-31 12:00:56 -040012 *
Kumar Gala8d04f022007-10-24 11:04:22 -050013 * 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.
Gerald Van Baren35748172007-03-31 12:00:56 -040050 */
51#include "libfdt_env.h"
52
Bartlomiej Sieka8cf30802008-02-29 16:00:24 +010053#ifndef USE_HOSTCC
Gerald Van Baren35748172007-03-31 12:00:56 -040054#include <fdt.h>
55#include <libfdt.h>
Bartlomiej Sieka8cf30802008-02-29 16:00:24 +010056#else
57#include "fdt_host.h"
58#endif
Gerald Van Baren35748172007-03-31 12:00:56 -040059
60#include "libfdt_internal.h"
61
Kumar Gala8d04f022007-10-24 11:04:22 -050062static int nodename_eq(const void *fdt, int offset,
63 const char *s, int len)
Gerald Van Baren35748172007-03-31 12:00:56 -040064{
David Gibsonae0b5902008-02-12 11:58:31 +110065 const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
Gerald Van Baren35748172007-03-31 12:00:56 -040066
67 if (! p)
68 /* short match */
69 return 0;
70
71 if (memcmp(p, s, len) != 0)
72 return 0;
73
Kumar Gala8d04f022007-10-24 11:04:22 -050074 if (p[len] == '\0')
75 return 1;
76 else if (!memchr(s, '@', len) && (p[len] == '@'))
77 return 1;
78 else
Gerald Van Baren35748172007-03-31 12:00:56 -040079 return 0;
Gerald Van Baren35748172007-03-31 12:00:56 -040080}
81
Kumar Gala8d04f022007-10-24 11:04:22 -050082const char *fdt_string(const void *fdt, int stroffset)
Gerald Van Baren35748172007-03-31 12:00:56 -040083{
84 return (char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
85}
86
Kumar Gala8d04f022007-10-24 11:04:22 -050087int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
88{
89 CHECK_HEADER(fdt);
90 *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
91 *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
92 return 0;
93}
94
95int fdt_num_mem_rsv(const void *fdt)
96{
97 int i = 0;
98
99 while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
100 i++;
101 return i;
102}
103
David Gibsonae0b5902008-02-12 11:58:31 +1100104int fdt_subnode_offset_namelen(const void *fdt, int offset,
Gerald Van Baren35748172007-03-31 12:00:56 -0400105 const char *name, int namelen)
106{
David Gibsonae0b5902008-02-12 11:58:31 +1100107 int depth;
Gerald Van Baren35748172007-03-31 12:00:56 -0400108
109 CHECK_HEADER(fdt);
110
David Gibsonae0b5902008-02-12 11:58:31 +1100111 for (depth = 0;
112 offset >= 0;
113 offset = fdt_next_node(fdt, offset, &depth)) {
114 if (depth < 0)
115 return -FDT_ERR_NOTFOUND;
116 else if ((depth == 1)
117 && nodename_eq(fdt, offset, name, namelen))
118 return offset;
119 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400120
David Gibsonae0b5902008-02-12 11:58:31 +1100121 return offset; /* error */
Gerald Van Baren35748172007-03-31 12:00:56 -0400122}
123
124int fdt_subnode_offset(const void *fdt, int parentoffset,
125 const char *name)
126{
127 return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
128}
129
Kumar Gala8d04f022007-10-24 11:04:22 -0500130int fdt_path_offset(const void *fdt, const char *path)
Gerald Van Baren35748172007-03-31 12:00:56 -0400131{
132 const char *end = path + strlen(path);
133 const char *p = path;
134 int offset = 0;
135
136 CHECK_HEADER(fdt);
137
138 if (*path != '/')
139 return -FDT_ERR_BADPATH;
140
141 while (*p) {
142 const char *q;
143
144 while (*p == '/')
145 p++;
146 if (! *p)
Kumar Gala8d04f022007-10-24 11:04:22 -0500147 return offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400148 q = strchr(p, '/');
149 if (! q)
150 q = end;
151
152 offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
153 if (offset < 0)
154 return offset;
155
156 p = q;
157 }
158
Gerald Van Barenaea03c42007-03-31 14:30:53 -0400159 return offset;
Gerald Van Baren35748172007-03-31 12:00:56 -0400160}
161
Kumar Gala8d04f022007-10-24 11:04:22 -0500162const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
Gerald Van Baren35748172007-03-31 12:00:56 -0400163{
Kumar Gala8d04f022007-10-24 11:04:22 -0500164 const struct fdt_node_header *nh;
165 int err;
166
167 if ((err = fdt_check_header(fdt)) != 0)
168 goto fail;
169
170 err = -FDT_ERR_BADOFFSET;
171 nh = fdt_offset_ptr(fdt, nodeoffset, sizeof(*nh));
172 if (!nh || (fdt32_to_cpu(nh->tag) != FDT_BEGIN_NODE))
173 goto fail;
174
175 if (len)
176 *len = strlen(nh->name);
177
178 return nh->name;
179
180 fail:
181 if (len)
182 *len = err;
183 return NULL;
184}
185
186const struct fdt_property *fdt_get_property(const void *fdt,
187 int nodeoffset,
188 const char *name, int *lenp)
189{
Gerald Van Baren35748172007-03-31 12:00:56 -0400190 uint32_t tag;
Kumar Gala8d04f022007-10-24 11:04:22 -0500191 const struct fdt_property *prop;
192 int namestroff;
Gerald Van Baren35748172007-03-31 12:00:56 -0400193 int offset, nextoffset;
194 int err;
195
Gerald Van Baren6679f922007-04-06 14:17:14 -0400196 if ((err = fdt_check_header(fdt)) != 0)
Gerald Van Baren35748172007-03-31 12:00:56 -0400197 goto fail;
198
199 err = -FDT_ERR_BADOFFSET;
200 if (nodeoffset % FDT_TAGSIZE)
201 goto fail;
202
Kumar Gala8d04f022007-10-24 11:04:22 -0500203 tag = fdt_next_tag(fdt, nodeoffset, &nextoffset);
Gerald Van Baren35748172007-03-31 12:00:56 -0400204 if (tag != FDT_BEGIN_NODE)
205 goto fail;
206
207 do {
208 offset = nextoffset;
209
Kumar Gala8d04f022007-10-24 11:04:22 -0500210 tag = fdt_next_tag(fdt, offset, &nextoffset);
Gerald Van Baren35748172007-03-31 12:00:56 -0400211 switch (tag) {
212 case FDT_END:
213 err = -FDT_ERR_TRUNCATED;
214 goto fail;
215
216 case FDT_BEGIN_NODE:
Gerald Van Baren35748172007-03-31 12:00:56 -0400217 case FDT_END_NODE:
Kumar Gala8d04f022007-10-24 11:04:22 -0500218 case FDT_NOP:
Gerald Van Baren35748172007-03-31 12:00:56 -0400219 break;
220
221 case FDT_PROP:
Kumar Gala8d04f022007-10-24 11:04:22 -0500222 err = -FDT_ERR_BADSTRUCTURE;
223 prop = fdt_offset_ptr(fdt, offset, sizeof(*prop));
224 if (! prop)
Gerald Van Baren9675ee72007-05-17 23:54:36 -0400225 goto fail;
Kumar Gala8d04f022007-10-24 11:04:22 -0500226 namestroff = fdt32_to_cpu(prop->nameoff);
227 if (streq(fdt_string(fdt, namestroff), name)) {
228 /* Found it! */
229 int len = fdt32_to_cpu(prop->len);
230 prop = fdt_offset_ptr(fdt, offset,
231 sizeof(*prop)+len);
232 if (! prop)
233 goto fail;
Gerald Van Baren35748172007-03-31 12:00:56 -0400234
Kumar Gala8d04f022007-10-24 11:04:22 -0500235 if (lenp)
236 *lenp = len;
237
238 return prop;
239 }
Gerald Van Baren35748172007-03-31 12:00:56 -0400240 break;
241
242 default:
243 err = -FDT_ERR_BADSTRUCTURE;
244 goto fail;
245 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500246 } while ((tag != FDT_BEGIN_NODE) && (tag != FDT_END_NODE));
Gerald Van Baren35748172007-03-31 12:00:56 -0400247
248 err = -FDT_ERR_NOTFOUND;
Kumar Gala8d04f022007-10-24 11:04:22 -0500249 fail:
Gerald Van Baren35748172007-03-31 12:00:56 -0400250 if (lenp)
251 *lenp = err;
252 return NULL;
253}
254
Kumar Gala8d04f022007-10-24 11:04:22 -0500255const void *fdt_getprop(const void *fdt, int nodeoffset,
Gerald Van Baren35748172007-03-31 12:00:56 -0400256 const char *name, int *lenp)
257{
258 const struct fdt_property *prop;
259
260 prop = fdt_get_property(fdt, nodeoffset, name, lenp);
261 if (! prop)
262 return NULL;
263
Kumar Gala8d04f022007-10-24 11:04:22 -0500264 return prop->data;
Gerald Van Baren35748172007-03-31 12:00:56 -0400265}
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400266
Kumar Gala8d04f022007-10-24 11:04:22 -0500267uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400268{
Kumar Gala8d04f022007-10-24 11:04:22 -0500269 const uint32_t *php;
270 int len;
271
272 php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
273 if (!php || (len != sizeof(*php)))
274 return 0;
275
276 return fdt32_to_cpu(*php);
277}
278
279int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
280{
David Gibsonae0b5902008-02-12 11:58:31 +1100281 int pdepth = 0, p = 0;
282 int offset, depth, namelen;
Kumar Gala8d04f022007-10-24 11:04:22 -0500283 const char *name;
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400284
Kumar Gala8d04f022007-10-24 11:04:22 -0500285 CHECK_HEADER(fdt);
Gerald Van Baren3af0d582007-03-31 12:13:43 -0400286
Kumar Gala8d04f022007-10-24 11:04:22 -0500287 if (buflen < 2)
Gerald Van Baren3f9f08c2007-04-14 22:46:41 -0400288 return -FDT_ERR_NOSPACE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500289
David Gibsonae0b5902008-02-12 11:58:31 +1100290 for (offset = 0, depth = 0;
291 (offset >= 0) && (offset <= nodeoffset);
292 offset = fdt_next_node(fdt, offset, &depth)) {
293 if (pdepth < depth)
294 continue; /* overflowed buffer */
Kumar Gala8d04f022007-10-24 11:04:22 -0500295
David Gibsonae0b5902008-02-12 11:58:31 +1100296 while (pdepth > depth) {
297 do {
298 p--;
299 } while (buf[p-1] != '/');
300 pdepth--;
301 }
302
303 name = fdt_get_name(fdt, offset, &namelen);
304 if (!name)
305 return namelen;
306 if ((p + namelen + 1) <= buflen) {
Kumar Gala8d04f022007-10-24 11:04:22 -0500307 memcpy(buf + p, name, namelen);
308 p += namelen;
309 buf[p++] = '/';
David Gibsonae0b5902008-02-12 11:58:31 +1100310 pdepth++;
311 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500312
David Gibsonae0b5902008-02-12 11:58:31 +1100313 if (offset == nodeoffset) {
314 if (pdepth < (depth + 1))
315 return -FDT_ERR_NOSPACE;
316
317 if (p > 1) /* special case so that root path is "/", not "" */
Kumar Gala8d04f022007-10-24 11:04:22 -0500318 p--;
David Gibsonae0b5902008-02-12 11:58:31 +1100319 buf[p] = '\0';
320 return p;
Kumar Gala8d04f022007-10-24 11:04:22 -0500321 }
322 }
323
David Gibsonae0b5902008-02-12 11:58:31 +1100324 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
325 return -FDT_ERR_BADOFFSET;
326 else if (offset == -FDT_ERR_BADOFFSET)
327 return -FDT_ERR_BADSTRUCTURE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500328
David Gibsonae0b5902008-02-12 11:58:31 +1100329 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500330}
331
332int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
333 int supernodedepth, int *nodedepth)
334{
David Gibsonae0b5902008-02-12 11:58:31 +1100335 int offset, depth;
Kumar Gala8d04f022007-10-24 11:04:22 -0500336 int supernodeoffset = -FDT_ERR_INTERNAL;
337
338 CHECK_HEADER(fdt);
339
340 if (supernodedepth < 0)
341 return -FDT_ERR_NOTFOUND;
342
David Gibsonae0b5902008-02-12 11:58:31 +1100343 for (offset = 0, depth = 0;
344 (offset >= 0) && (offset <= nodeoffset);
345 offset = fdt_next_node(fdt, offset, &depth)) {
346 if (depth == supernodedepth)
347 supernodeoffset = offset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500348
David Gibsonae0b5902008-02-12 11:58:31 +1100349 if (offset == nodeoffset) {
350 if (nodedepth)
351 *nodedepth = depth;
Kumar Gala8d04f022007-10-24 11:04:22 -0500352
David Gibsonae0b5902008-02-12 11:58:31 +1100353 if (supernodedepth > depth)
354 return -FDT_ERR_NOTFOUND;
355 else
356 return supernodeoffset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500357 }
David Gibsonae0b5902008-02-12 11:58:31 +1100358 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500359
David Gibsonae0b5902008-02-12 11:58:31 +1100360 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
361 return -FDT_ERR_BADOFFSET;
362 else if (offset == -FDT_ERR_BADOFFSET)
363 return -FDT_ERR_BADSTRUCTURE;
Kumar Gala8d04f022007-10-24 11:04:22 -0500364
David Gibsonae0b5902008-02-12 11:58:31 +1100365 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500366}
367
368int fdt_node_depth(const void *fdt, int nodeoffset)
369{
370 int nodedepth;
371 int err;
372
373 err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
374 if (err)
375 return (err < 0) ? err : -FDT_ERR_INTERNAL;
376 return nodedepth;
377}
378
379int fdt_parent_offset(const void *fdt, int nodeoffset)
380{
381 int nodedepth = fdt_node_depth(fdt, nodeoffset);
382
383 if (nodedepth < 0)
384 return nodedepth;
385 return fdt_supernode_atdepth_offset(fdt, nodeoffset,
386 nodedepth - 1, NULL);
387}
388
389int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
390 const char *propname,
391 const void *propval, int proplen)
392{
David Gibsonae0b5902008-02-12 11:58:31 +1100393 int offset;
Kumar Gala8d04f022007-10-24 11:04:22 -0500394 const void *val;
395 int len;
396
397 CHECK_HEADER(fdt);
398
Kumar Gala8d04f022007-10-24 11:04:22 -0500399 /* FIXME: The algorithm here is pretty horrible: we scan each
400 * property of a node in fdt_getprop(), then if that didn't
401 * find what we want, we scan over them again making our way
402 * to the next node. Still it's the easiest to implement
403 * approach; performance can come later. */
David Gibsonae0b5902008-02-12 11:58:31 +1100404 for (offset = fdt_next_node(fdt, startoffset, NULL);
405 offset >= 0;
406 offset = fdt_next_node(fdt, offset, NULL)) {
407 val = fdt_getprop(fdt, offset, propname, &len);
408 if (val && (len == proplen)
409 && (memcmp(val, propval, len) == 0))
410 return offset;
411 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500412
David Gibsonae0b5902008-02-12 11:58:31 +1100413 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500414}
415
416int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
417{
418 if ((phandle == 0) || (phandle == -1))
419 return -FDT_ERR_BADPHANDLE;
420 phandle = cpu_to_fdt32(phandle);
421 return fdt_node_offset_by_prop_value(fdt, -1, "linux,phandle",
422 &phandle, sizeof(phandle));
423}
424
425int _stringlist_contains(const void *strlist, int listlen, const char *str)
426{
427 int len = strlen(str);
428 const void *p;
429
430 while (listlen >= len) {
431 if (memcmp(str, strlist, len+1) == 0)
432 return 1;
433 p = memchr(strlist, '\0', listlen);
434 if (!p)
435 return 0; /* malformed strlist.. */
436 listlen -= (p-strlist) + 1;
437 strlist = p + 1;
Gerald Van Baren3f9f08c2007-04-14 22:46:41 -0400438 }
439 return 0;
440}
Kumar Gala8d04f022007-10-24 11:04:22 -0500441
442int fdt_node_check_compatible(const void *fdt, int nodeoffset,
443 const char *compatible)
444{
445 const void *prop;
446 int len;
447
448 prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
449 if (!prop)
450 return len;
451 if (_stringlist_contains(prop, len, compatible))
452 return 0;
453 else
454 return 1;
455}
456
457int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
458 const char *compatible)
459{
David Gibson11abe452008-02-18 18:09:04 +1100460 int offset, err;
Kumar Gala8d04f022007-10-24 11:04:22 -0500461
462 CHECK_HEADER(fdt);
463
Kumar Gala8d04f022007-10-24 11:04:22 -0500464 /* FIXME: The algorithm here is pretty horrible: we scan each
465 * property of a node in fdt_node_check_compatible(), then if
466 * that didn't find what we want, we scan over them again
467 * making our way to the next node. Still it's the easiest to
468 * implement approach; performance can come later. */
David Gibsonae0b5902008-02-12 11:58:31 +1100469 for (offset = fdt_next_node(fdt, startoffset, NULL);
470 offset >= 0;
471 offset = fdt_next_node(fdt, offset, NULL)) {
472 err = fdt_node_check_compatible(fdt, offset, compatible);
473 if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
474 return err;
475 else if (err == 0)
476 return offset;
477 }
Kumar Gala8d04f022007-10-24 11:04:22 -0500478
David Gibsonae0b5902008-02-12 11:58:31 +1100479 return offset; /* error from fdt_next_node() */
Kumar Gala8d04f022007-10-24 11:04:22 -0500480}