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 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 78 const char *fdt_string(const void *fdt, int stroffset) 79 { 80 return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset; 81 } 82 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 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 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 108 int fdt_subnode_offset_namelen(const void *fdt, int offset, 109 const char *name, int namelen) 110 { 111 int depth; 112 113 FDT_CHECK_HEADER(fdt); 114 115 for (depth = 0; 116 (offset >= 0) && (depth >= 0); 117 offset = fdt_next_node(fdt, offset, &depth)) 118 if ((depth == 1) 119 && _fdt_nodename_eq(fdt, offset, name, namelen)) 120 return offset; 121 122 if (depth < 0) 123 return -FDT_ERR_NOTFOUND; 124 return offset; /* error */ 125 } 126 127 int fdt_subnode_offset(const void *fdt, int parentoffset, 128 const char *name) 129 { 130 return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name)); 131 } 132 133 int fdt_path_offset(const void *fdt, const char *path) 134 { 135 const char *end = path + strlen(path); 136 const char *p = path; 137 int offset = 0; 138 139 FDT_CHECK_HEADER(fdt); 140 141 /* see if we have an alias */ 142 if (*path != '/') { 143 const char *q = strchr(path, '/'); 144 145 if (!q) 146 q = end; 147 148 p = fdt_get_alias_namelen(fdt, p, q - p); 149 if (!p) 150 return -FDT_ERR_BADPATH; 151 offset = fdt_path_offset(fdt, p); 152 153 p = q; 154 } 155 156 while (*p) { 157 const char *q; 158 159 while (*p == '/') 160 p++; 161 if (! *p) 162 return offset; 163 q = strchr(p, '/'); 164 if (! q) 165 q = end; 166 167 offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p); 168 if (offset < 0) 169 return offset; 170 171 p = q; 172 } 173 174 return offset; 175 } 176 177 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len) 178 { 179 const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset); 180 int err; 181 182 if (((err = fdt_check_header(fdt)) != 0) 183 || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0)) 184 goto fail; 185 186 if (len) 187 *len = strlen(nh->name); 188 189 return nh->name; 190 191 fail: 192 if (len) 193 *len = err; 194 return NULL; 195 } 196 197 const struct fdt_property *fdt_get_property_namelen(const void *fdt, 198 int nodeoffset, 199 const char *name, 200 int namelen, int *lenp) 201 { 202 uint32_t tag; 203 const struct fdt_property *prop; 204 int offset, nextoffset; 205 int err; 206 207 if (((err = fdt_check_header(fdt)) != 0) 208 || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0)) 209 goto fail; 210 211 nextoffset = err; 212 do { 213 offset = nextoffset; 214 215 tag = fdt_next_tag(fdt, offset, &nextoffset); 216 switch (tag) { 217 case FDT_END: 218 if (nextoffset < 0) 219 err = nextoffset; 220 else 221 /* FDT_END tag with unclosed nodes */ 222 err = -FDT_ERR_BADSTRUCTURE; 223 goto fail; 224 225 case FDT_PROP: 226 prop = _fdt_offset_ptr(fdt, offset); 227 if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff), 228 name, namelen)) { 229 /* Found it! */ 230 if (lenp) 231 *lenp = fdt32_to_cpu(prop->len); 232 233 return prop; 234 } 235 break; 236 } 237 } while ((tag != FDT_BEGIN_NODE) && (tag != FDT_END_NODE)); 238 239 err = -FDT_ERR_NOTFOUND; 240 fail: 241 if (lenp) 242 *lenp = err; 243 return NULL; 244 } 245 246 const struct fdt_property *fdt_get_property(const void *fdt, 247 int nodeoffset, 248 const char *name, int *lenp) 249 { 250 return fdt_get_property_namelen(fdt, nodeoffset, name, 251 strlen(name), lenp); 252 } 253 254 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset, 255 const char *name, int namelen, int *lenp) 256 { 257 const struct fdt_property *prop; 258 259 prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp); 260 if (! prop) 261 return NULL; 262 263 return prop->data; 264 } 265 266 const void *fdt_getprop(const void *fdt, int nodeoffset, 267 const char *name, int *lenp) 268 { 269 return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp); 270 } 271 272 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset) 273 { 274 const uint32_t *php; 275 int len; 276 277 /* FIXME: This is a bit sub-optimal, since we potentially scan 278 * over all the properties twice. */ 279 php = fdt_getprop(fdt, nodeoffset, "phandle", &len); 280 if (!php || (len != sizeof(*php))) { 281 php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len); 282 if (!php || (len != sizeof(*php))) 283 return 0; 284 } 285 286 return fdt32_to_cpu(*php); 287 } 288 289 const char *fdt_get_alias_namelen(const void *fdt, 290 const char *name, int namelen) 291 { 292 int aliasoffset; 293 294 aliasoffset = fdt_path_offset(fdt, "/aliases"); 295 if (aliasoffset < 0) 296 return NULL; 297 298 return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL); 299 } 300 301 const char *fdt_get_alias(const void *fdt, const char *name) 302 { 303 return fdt_get_alias_namelen(fdt, name, strlen(name)); 304 } 305 306 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen) 307 { 308 int pdepth = 0, p = 0; 309 int offset, depth, namelen; 310 const char *name; 311 312 FDT_CHECK_HEADER(fdt); 313 314 if (buflen < 2) 315 return -FDT_ERR_NOSPACE; 316 317 for (offset = 0, depth = 0; 318 (offset >= 0) && (offset <= nodeoffset); 319 offset = fdt_next_node(fdt, offset, &depth)) { 320 while (pdepth > depth) { 321 do { 322 p--; 323 } while (buf[p-1] != '/'); 324 pdepth--; 325 } 326 327 if (pdepth >= depth) { 328 name = fdt_get_name(fdt, offset, &namelen); 329 if (!name) 330 return namelen; 331 if ((p + namelen + 1) <= buflen) { 332 memcpy(buf + p, name, namelen); 333 p += namelen; 334 buf[p++] = '/'; 335 pdepth++; 336 } 337 } 338 339 if (offset == nodeoffset) { 340 if (pdepth < (depth + 1)) 341 return -FDT_ERR_NOSPACE; 342 343 if (p > 1) /* special case so that root path is "/", not "" */ 344 p--; 345 buf[p] = '\0'; 346 return 0; 347 } 348 } 349 350 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) 351 return -FDT_ERR_BADOFFSET; 352 else if (offset == -FDT_ERR_BADOFFSET) 353 return -FDT_ERR_BADSTRUCTURE; 354 355 return offset; /* error from fdt_next_node() */ 356 } 357 358 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset, 359 int supernodedepth, int *nodedepth) 360 { 361 int offset, depth; 362 int supernodeoffset = -FDT_ERR_INTERNAL; 363 364 FDT_CHECK_HEADER(fdt); 365 366 if (supernodedepth < 0) 367 return -FDT_ERR_NOTFOUND; 368 369 for (offset = 0, depth = 0; 370 (offset >= 0) && (offset <= nodeoffset); 371 offset = fdt_next_node(fdt, offset, &depth)) { 372 if (depth == supernodedepth) 373 supernodeoffset = offset; 374 375 if (offset == nodeoffset) { 376 if (nodedepth) 377 *nodedepth = depth; 378 379 if (supernodedepth > depth) 380 return -FDT_ERR_NOTFOUND; 381 else 382 return supernodeoffset; 383 } 384 } 385 386 if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) 387 return -FDT_ERR_BADOFFSET; 388 else if (offset == -FDT_ERR_BADOFFSET) 389 return -FDT_ERR_BADSTRUCTURE; 390 391 return offset; /* error from fdt_next_node() */ 392 } 393 394 int fdt_node_depth(const void *fdt, int nodeoffset) 395 { 396 int nodedepth; 397 int err; 398 399 err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth); 400 if (err) 401 return (err < 0) ? err : -FDT_ERR_INTERNAL; 402 return nodedepth; 403 } 404 405 int fdt_parent_offset(const void *fdt, int nodeoffset) 406 { 407 int nodedepth = fdt_node_depth(fdt, nodeoffset); 408 409 if (nodedepth < 0) 410 return nodedepth; 411 return fdt_supernode_atdepth_offset(fdt, nodeoffset, 412 nodedepth - 1, NULL); 413 } 414 415 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset, 416 const char *propname, 417 const void *propval, int proplen) 418 { 419 int offset; 420 const void *val; 421 int len; 422 423 FDT_CHECK_HEADER(fdt); 424 425 /* FIXME: The algorithm here is pretty horrible: we scan each 426 * property of a node in fdt_getprop(), then if that didn't 427 * find what we want, we scan over them again making our way 428 * to the next node. Still it's the easiest to implement 429 * approach; performance can come later. */ 430 for (offset = fdt_next_node(fdt, startoffset, NULL); 431 offset >= 0; 432 offset = fdt_next_node(fdt, offset, NULL)) { 433 val = fdt_getprop(fdt, offset, propname, &len); 434 if (val && (len == proplen) 435 && (memcmp(val, propval, len) == 0)) 436 return offset; 437 } 438 439 return offset; /* error from fdt_next_node() */ 440 } 441 442 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle) 443 { 444 int offset; 445 446 if ((phandle == 0) || (phandle == -1)) 447 return -FDT_ERR_BADPHANDLE; 448 449 FDT_CHECK_HEADER(fdt); 450 451 /* FIXME: The algorithm here is pretty horrible: we 452 * potentially scan each property of a node in 453 * fdt_get_phandle(), then if that didn't find what 454 * we want, we scan over them again making our way to the next 455 * node. Still it's the easiest to implement approach; 456 * performance can come later. */ 457 for (offset = fdt_next_node(fdt, -1, NULL); 458 offset >= 0; 459 offset = fdt_next_node(fdt, offset, NULL)) { 460 if (fdt_get_phandle(fdt, offset) == phandle) 461 return offset; 462 } 463 464 return offset; /* error from fdt_next_node() */ 465 } 466 467 static int _fdt_stringlist_contains(const char *strlist, int listlen, 468 const char *str) 469 { 470 int len = strlen(str); 471 const char *p; 472 473 while (listlen >= len) { 474 if (memcmp(str, strlist, len+1) == 0) 475 return 1; 476 p = memchr(strlist, '\0', listlen); 477 if (!p) 478 return 0; /* malformed strlist.. */ 479 listlen -= (p-strlist) + 1; 480 strlist = p + 1; 481 } 482 return 0; 483 } 484 485 int fdt_node_check_compatible(const void *fdt, int nodeoffset, 486 const char *compatible) 487 { 488 const void *prop; 489 int len; 490 491 prop = fdt_getprop(fdt, nodeoffset, "compatible", &len); 492 if (!prop) 493 return len; 494 if (_fdt_stringlist_contains(prop, len, compatible)) 495 return 0; 496 else 497 return 1; 498 } 499 500 int fdt_node_offset_by_compatible(const void *fdt, int startoffset, 501 const char *compatible) 502 { 503 int offset, err; 504 505 FDT_CHECK_HEADER(fdt); 506 507 /* FIXME: The algorithm here is pretty horrible: we scan each 508 * property of a node in fdt_node_check_compatible(), then if 509 * that didn't find what we want, we scan over them again 510 * making our way to the next node. Still it's the easiest to 511 * implement approach; performance can come later. */ 512 for (offset = fdt_next_node(fdt, startoffset, NULL); 513 offset >= 0; 514 offset = fdt_next_node(fdt, offset, NULL)) { 515 err = fdt_node_check_compatible(fdt, offset, compatible); 516 if ((err < 0) && (err != -FDT_ERR_NOTFOUND)) 517 return err; 518 else if (err == 0) 519 return offset; 520 } 521 522 return offset; /* error from fdt_next_node() */ 523 } 524