1/* 2 * Procedures for creating, accessing and interpreting the device tree. 3 * 4 * Paul Mackerras August 1996. 5 * Copyright (C) 1996-2005 Paul Mackerras. 6 * 7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 8 * {engebret|bergner}@us.ibm.com 9 * 10 * Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net 11 * 12 * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and 13 * Grant Likely. 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License 17 * as published by the Free Software Foundation; either version 18 * 2 of the License, or (at your option) any later version. 19 */ 20#include <linux/ctype.h> 21#include <linux/module.h> 22#include <linux/of.h> 23#include <linux/spinlock.h> 24#include <linux/slab.h> 25#include <linux/proc_fs.h> 26 27/** 28 * struct alias_prop - Alias property in 'aliases' node 29 * @link: List node to link the structure in aliases_lookup list 30 * @alias: Alias property name 31 * @np: Pointer to device_node that the alias stands for 32 * @id: Index value from end of alias name 33 * @stem: Alias string without the index 34 * 35 * The structure represents one alias property of 'aliases' node as 36 * an entry in aliases_lookup list. 37 */ 38struct alias_prop { 39 struct list_head link; 40 const char *alias; 41 struct device_node *np; 42 int id; 43 char stem[0]; 44}; 45 46static LIST_HEAD(aliases_lookup); 47 48struct device_node *allnodes; 49struct device_node *of_chosen; 50struct device_node *of_aliases; 51 52static DEFINE_MUTEX(of_aliases_mutex); 53 54/* use when traversing tree through the allnext, child, sibling, 55 * or parent members of struct device_node. 56 */ 57DEFINE_RWLOCK(devtree_lock); 58 59int of_n_addr_cells(struct device_node *np) 60{ 61 const __be32 *ip; 62 63 do { 64 if (np->parent) 65 np = np->parent; 66 ip = of_get_property(np, "#address-cells", NULL); 67 if (ip) 68 return be32_to_cpup(ip); 69 } while (np->parent); 70 /* No #address-cells property for the root node */ 71 return OF_ROOT_NODE_ADDR_CELLS_DEFAULT; 72} 73EXPORT_SYMBOL(of_n_addr_cells); 74 75int of_n_size_cells(struct device_node *np) 76{ 77 const __be32 *ip; 78 79 do { 80 if (np->parent) 81 np = np->parent; 82 ip = of_get_property(np, "#size-cells", NULL); 83 if (ip) 84 return be32_to_cpup(ip); 85 } while (np->parent); 86 /* No #size-cells property for the root node */ 87 return OF_ROOT_NODE_SIZE_CELLS_DEFAULT; 88} 89EXPORT_SYMBOL(of_n_size_cells); 90 91#if defined(CONFIG_OF_DYNAMIC) 92/** 93 * of_node_get - Increment refcount of a node 94 * @node: Node to inc refcount, NULL is supported to 95 * simplify writing of callers 96 * 97 * Returns node. 98 */ 99struct device_node *of_node_get(struct device_node *node) 100{ 101 if (node) 102 kref_get(&node->kref); 103 return node; 104} 105EXPORT_SYMBOL(of_node_get); 106 107static inline struct device_node *kref_to_device_node(struct kref *kref) 108{ 109 return container_of(kref, struct device_node, kref); 110} 111 112/** 113 * of_node_release - release a dynamically allocated node 114 * @kref: kref element of the node to be released 115 * 116 * In of_node_put() this function is passed to kref_put() 117 * as the destructor. 118 */ 119static void of_node_release(struct kref *kref) 120{ 121 struct device_node *node = kref_to_device_node(kref); 122 struct property *prop = node->properties; 123 124 /* We should never be releasing nodes that haven't been detached. */ 125 if (!of_node_check_flag(node, OF_DETACHED)) { 126 pr_err("ERROR: Bad of_node_put() on %s\n", node->full_name); 127 dump_stack(); 128 kref_init(&node->kref); 129 return; 130 } 131 132 if (!of_node_check_flag(node, OF_DYNAMIC)) 133 return; 134 135 while (prop) { 136 struct property *next = prop->next; 137 kfree(prop->name); 138 kfree(prop->value); 139 kfree(prop); 140 prop = next; 141 142 if (!prop) { 143 prop = node->deadprops; 144 node->deadprops = NULL; 145 } 146 } 147 kfree(node->full_name); 148 kfree(node->data); 149 kfree(node); 150} 151 152/** 153 * of_node_put - Decrement refcount of a node 154 * @node: Node to dec refcount, NULL is supported to 155 * simplify writing of callers 156 * 157 */ 158void of_node_put(struct device_node *node) 159{ 160 if (node) 161 kref_put(&node->kref, of_node_release); 162} 163EXPORT_SYMBOL(of_node_put); 164#endif /* CONFIG_OF_DYNAMIC */ 165 166struct property *of_find_property(const struct device_node *np, 167 const char *name, 168 int *lenp) 169{ 170 struct property *pp; 171 172 if (!np) 173 return NULL; 174 175 read_lock(&devtree_lock); 176 for (pp = np->properties; pp != 0; pp = pp->next) { 177 if (of_prop_cmp(pp->name, name) == 0) { 178 if (lenp != 0) 179 *lenp = pp->length; 180 break; 181 } 182 } 183 read_unlock(&devtree_lock); 184 185 return pp; 186} 187EXPORT_SYMBOL(of_find_property); 188 189/** 190 * of_find_all_nodes - Get next node in global list 191 * @prev: Previous node or NULL to start iteration 192 * of_node_put() will be called on it 193 * 194 * Returns a node pointer with refcount incremented, use 195 * of_node_put() on it when done. 196 */ 197struct device_node *of_find_all_nodes(struct device_node *prev) 198{ 199 struct device_node *np; 200 201 read_lock(&devtree_lock); 202 np = prev ? prev->allnext : allnodes; 203 for (; np != NULL; np = np->allnext) 204 if (of_node_get(np)) 205 break; 206 of_node_put(prev); 207 read_unlock(&devtree_lock); 208 return np; 209} 210EXPORT_SYMBOL(of_find_all_nodes); 211 212/* 213 * Find a property with a given name for a given node 214 * and return the value. 215 */ 216const void *of_get_property(const struct device_node *np, const char *name, 217 int *lenp) 218{ 219 struct property *pp = of_find_property(np, name, lenp); 220 221 return pp ? pp->value : NULL; 222} 223EXPORT_SYMBOL(of_get_property); 224 225/** Checks if the given "compat" string matches one of the strings in 226 * the device's "compatible" property 227 */ 228int of_device_is_compatible(const struct device_node *device, 229 const char *compat) 230{ 231 const char* cp; 232 int cplen, l; 233 234 cp = of_get_property(device, "compatible", &cplen); 235 if (cp == NULL) 236 return 0; 237 while (cplen > 0) { 238 if (of_compat_cmp(cp, compat, strlen(compat)) == 0) 239 return 1; 240 l = strlen(cp) + 1; 241 cp += l; 242 cplen -= l; 243 } 244 245 return 0; 246} 247EXPORT_SYMBOL(of_device_is_compatible); 248 249/** 250 * of_machine_is_compatible - Test root of device tree for a given compatible value 251 * @compat: compatible string to look for in root node's compatible property. 252 * 253 * Returns true if the root node has the given value in its 254 * compatible property. 255 */ 256int of_machine_is_compatible(const char *compat) 257{ 258 struct device_node *root; 259 int rc = 0; 260 261 root = of_find_node_by_path("/"); 262 if (root) { 263 rc = of_device_is_compatible(root, compat); 264 of_node_put(root); 265 } 266 return rc; 267} 268EXPORT_SYMBOL(of_machine_is_compatible); 269 270/** 271 * of_device_is_available - check if a device is available for use 272 * 273 * @device: Node to check for availability 274 * 275 * Returns 1 if the status property is absent or set to "okay" or "ok", 276 * 0 otherwise 277 */ 278int of_device_is_available(const struct device_node *device) 279{ 280 const char *status; 281 int statlen; 282 283 status = of_get_property(device, "status", &statlen); 284 if (status == NULL) 285 return 1; 286 287 if (statlen > 0) { 288 if (!strcmp(status, "okay") || !strcmp(status, "ok")) 289 return 1; 290 } 291 292 return 0; 293} 294EXPORT_SYMBOL(of_device_is_available); 295 296/** 297 * of_get_parent - Get a node's parent if any 298 * @node: Node to get parent 299 * 300 * Returns a node pointer with refcount incremented, use 301 * of_node_put() on it when done. 302 */ 303struct device_node *of_get_parent(const struct device_node *node) 304{ 305 struct device_node *np; 306 307 if (!node) 308 return NULL; 309 310 read_lock(&devtree_lock); 311 np = of_node_get(node->parent); 312 read_unlock(&devtree_lock); 313 return np; 314} 315EXPORT_SYMBOL(of_get_parent); 316 317/** 318 * of_get_next_parent - Iterate to a node's parent 319 * @node: Node to get parent of 320 * 321 * This is like of_get_parent() except that it drops the 322 * refcount on the passed node, making it suitable for iterating 323 * through a node's parents. 324 * 325 * Returns a node pointer with refcount incremented, use 326 * of_node_put() on it when done. 327 */ 328struct device_node *of_get_next_parent(struct device_node *node) 329{ 330 struct device_node *parent; 331 332 if (!node) 333 return NULL; 334 335 read_lock(&devtree_lock); 336 parent = of_node_get(node->parent); 337 of_node_put(node); 338 read_unlock(&devtree_lock); 339 return parent; 340} 341 342/** 343 * of_get_next_child - Iterate a node childs 344 * @node: parent node 345 * @prev: previous child of the parent node, or NULL to get first 346 * 347 * Returns a node pointer with refcount incremented, use 348 * of_node_put() on it when done. 349 */ 350struct device_node *of_get_next_child(const struct device_node *node, 351 struct device_node *prev) 352{ 353 struct device_node *next; 354 355 read_lock(&devtree_lock); 356 next = prev ? prev->sibling : node->child; 357 for (; next; next = next->sibling) 358 if (of_node_get(next)) 359 break; 360 of_node_put(prev); 361 read_unlock(&devtree_lock); 362 return next; 363} 364EXPORT_SYMBOL(of_get_next_child); 365 366/** 367 * of_find_node_by_path - Find a node matching a full OF path 368 * @path: The full path to match 369 * 370 * Returns a node pointer with refcount incremented, use 371 * of_node_put() on it when done. 372 */ 373struct device_node *of_find_node_by_path(const char *path) 374{ 375 struct device_node *np = allnodes; 376 377 read_lock(&devtree_lock); 378 for (; np; np = np->allnext) { 379 if (np->full_name && (of_node_cmp(np->full_name, path) == 0) 380 && of_node_get(np)) 381 break; 382 } 383 read_unlock(&devtree_lock); 384 return np; 385} 386EXPORT_SYMBOL(of_find_node_by_path); 387 388/** 389 * of_find_node_by_name - Find a node by its "name" property 390 * @from: The node to start searching from or NULL, the node 391 * you pass will not be searched, only the next one 392 * will; typically, you pass what the previous call 393 * returned. of_node_put() will be called on it 394 * @name: The name string to match against 395 * 396 * Returns a node pointer with refcount incremented, use 397 * of_node_put() on it when done. 398 */ 399struct device_node *of_find_node_by_name(struct device_node *from, 400 const char *name) 401{ 402 struct device_node *np; 403 404 read_lock(&devtree_lock); 405 np = from ? from->allnext : allnodes; 406 for (; np; np = np->allnext) 407 if (np->name && (of_node_cmp(np->name, name) == 0) 408 && of_node_get(np)) 409 break; 410 of_node_put(from); 411 read_unlock(&devtree_lock); 412 return np; 413} 414EXPORT_SYMBOL(of_find_node_by_name); 415 416/** 417 * of_find_node_by_type - Find a node by its "device_type" property 418 * @from: The node to start searching from, or NULL to start searching 419 * the entire device tree. The node you pass will not be 420 * searched, only the next one will; typically, you pass 421 * what the previous call returned. of_node_put() will be 422 * called on from for you. 423 * @type: The type string to match against 424 * 425 * Returns a node pointer with refcount incremented, use 426 * of_node_put() on it when done. 427 */ 428struct device_node *of_find_node_by_type(struct device_node *from, 429 const char *type) 430{ 431 struct device_node *np; 432 433 read_lock(&devtree_lock); 434 np = from ? from->allnext : allnodes; 435 for (; np; np = np->allnext) 436 if (np->type && (of_node_cmp(np->type, type) == 0) 437 && of_node_get(np)) 438 break; 439 of_node_put(from); 440 read_unlock(&devtree_lock); 441 return np; 442} 443EXPORT_SYMBOL(of_find_node_by_type); 444 445/** 446 * of_find_compatible_node - Find a node based on type and one of the 447 * tokens in its "compatible" property 448 * @from: The node to start searching from or NULL, the node 449 * you pass will not be searched, only the next one 450 * will; typically, you pass what the previous call 451 * returned. of_node_put() will be called on it 452 * @type: The type string to match "device_type" or NULL to ignore 453 * @compatible: The string to match to one of the tokens in the device 454 * "compatible" list. 455 * 456 * Returns a node pointer with refcount incremented, use 457 * of_node_put() on it when done. 458 */ 459struct device_node *of_find_compatible_node(struct device_node *from, 460 const char *type, const char *compatible) 461{ 462 struct device_node *np; 463 464 read_lock(&devtree_lock); 465 np = from ? from->allnext : allnodes; 466 for (; np; np = np->allnext) { 467 if (type 468 && !(np->type && (of_node_cmp(np->type, type) == 0))) 469 continue; 470 if (of_device_is_compatible(np, compatible) && of_node_get(np)) 471 break; 472 } 473 of_node_put(from); 474 read_unlock(&devtree_lock); 475 return np; 476} 477EXPORT_SYMBOL(of_find_compatible_node); 478 479/** 480 * of_find_node_with_property - Find a node which has a property with 481 * the given name. 482 * @from: The node to start searching from or NULL, the node 483 * you pass will not be searched, only the next one 484 * will; typically, you pass what the previous call 485 * returned. of_node_put() will be called on it 486 * @prop_name: The name of the property to look for. 487 * 488 * Returns a node pointer with refcount incremented, use 489 * of_node_put() on it when done. 490 */ 491struct device_node *of_find_node_with_property(struct device_node *from, 492 const char *prop_name) 493{ 494 struct device_node *np; 495 struct property *pp; 496 497 read_lock(&devtree_lock); 498 np = from ? from->allnext : allnodes; 499 for (; np; np = np->allnext) { 500 for (pp = np->properties; pp != 0; pp = pp->next) { 501 if (of_prop_cmp(pp->name, prop_name) == 0) { 502 of_node_get(np); 503 goto out; 504 } 505 } 506 } 507out: 508 of_node_put(from); 509 read_unlock(&devtree_lock); 510 return np; 511} 512EXPORT_SYMBOL(of_find_node_with_property); 513 514/** 515 * of_match_node - Tell if an device_node has a matching of_match structure 516 * @matches: array of of device match structures to search in 517 * @node: the of device structure to match against 518 * 519 * Low level utility function used by device matching. 520 */ 521const struct of_device_id *of_match_node(const struct of_device_id *matches, 522 const struct device_node *node) 523{ 524 if (!matches) 525 return NULL; 526 527 while (matches->name[0] || matches->type[0] || matches->compatible[0]) { 528 int match = 1; 529 if (matches->name[0]) 530 match &= node->name 531 && !strcmp(matches->name, node->name); 532 if (matches->type[0]) 533 match &= node->type 534 && !strcmp(matches->type, node->type); 535 if (matches->compatible[0]) 536 match &= of_device_is_compatible(node, 537 matches->compatible); 538 if (match) 539 return matches; 540 matches++; 541 } 542 return NULL; 543} 544EXPORT_SYMBOL(of_match_node); 545 546/** 547 * of_find_matching_node - Find a node based on an of_device_id match 548 * table. 549 * @from: The node to start searching from or NULL, the node 550 * you pass will not be searched, only the next one 551 * will; typically, you pass what the previous call 552 * returned. of_node_put() will be called on it 553 * @matches: array of of device match structures to search in 554 * 555 * Returns a node pointer with refcount incremented, use 556 * of_node_put() on it when done. 557 */ 558struct device_node *of_find_matching_node(struct device_node *from, 559 const struct of_device_id *matches) 560{ 561 struct device_node *np; 562 563 read_lock(&devtree_lock); 564 np = from ? from->allnext : allnodes; 565 for (; np; np = np->allnext) { 566 if (of_match_node(matches, np) && of_node_get(np)) 567 break; 568 } 569 of_node_put(from); 570 read_unlock(&devtree_lock); 571 return np; 572} 573EXPORT_SYMBOL(of_find_matching_node); 574 575/** 576 * of_modalias_node - Lookup appropriate modalias for a device node 577 * @node: pointer to a device tree node 578 * @modalias: Pointer to buffer that modalias value will be copied into 579 * @len: Length of modalias value 580 * 581 * Based on the value of the compatible property, this routine will attempt 582 * to choose an appropriate modalias value for a particular device tree node. 583 * It does this by stripping the manufacturer prefix (as delimited by a ',') 584 * from the first entry in the compatible list property. 585 * 586 * This routine returns 0 on success, <0 on failure. 587 */ 588int of_modalias_node(struct device_node *node, char *modalias, int len) 589{ 590 const char *compatible, *p; 591 int cplen; 592 593 compatible = of_get_property(node, "compatible", &cplen); 594 if (!compatible || strlen(compatible) > cplen) 595 return -ENODEV; 596 p = strchr(compatible, ','); 597 strlcpy(modalias, p ? p + 1 : compatible, len); 598 return 0; 599} 600EXPORT_SYMBOL_GPL(of_modalias_node); 601 602/** 603 * of_find_node_by_phandle - Find a node given a phandle 604 * @handle: phandle of the node to find 605 * 606 * Returns a node pointer with refcount incremented, use 607 * of_node_put() on it when done. 608 */ 609struct device_node *of_find_node_by_phandle(phandle handle) 610{ 611 struct device_node *np; 612 613 read_lock(&devtree_lock); 614 for (np = allnodes; np; np = np->allnext) 615 if (np->phandle == handle) 616 break; 617 of_node_get(np); 618 read_unlock(&devtree_lock); 619 return np; 620} 621EXPORT_SYMBOL(of_find_node_by_phandle); 622 623/** 624 * of_property_read_u32_array - Find and read an array of 32 bit integers 625 * from a property. 626 * 627 * @np: device node from which the property value is to be read. 628 * @propname: name of the property to be searched. 629 * @out_value: pointer to return value, modified only if return value is 0. 630 * 631 * Search for a property in a device node and read 32-bit value(s) from 632 * it. Returns 0 on success, -EINVAL if the property does not exist, 633 * -ENODATA if property does not have a value, and -EOVERFLOW if the 634 * property data isn't large enough. 635 * 636 * The out_value is modified only if a valid u32 value can be decoded. 637 */ 638int of_property_read_u32_array(const struct device_node *np, 639 const char *propname, u32 *out_values, 640 size_t sz) 641{ 642 struct property *prop = of_find_property(np, propname, NULL); 643 const __be32 *val; 644 645 if (!prop) 646 return -EINVAL; 647 if (!prop->value) 648 return -ENODATA; 649 if ((sz * sizeof(*out_values)) > prop->length) 650 return -EOVERFLOW; 651 652 val = prop->value; 653 while (sz--) 654 *out_values++ = be32_to_cpup(val++); 655 return 0; 656} 657EXPORT_SYMBOL_GPL(of_property_read_u32_array); 658 659/** 660 * of_property_read_u64 - Find and read a 64 bit integer from a property 661 * @np: device node from which the property value is to be read. 662 * @propname: name of the property to be searched. 663 * @out_value: pointer to return value, modified only if return value is 0. 664 * 665 * Search for a property in a device node and read a 64-bit value from 666 * it. Returns 0 on success, -EINVAL if the property does not exist, 667 * -ENODATA if property does not have a value, and -EOVERFLOW if the 668 * property data isn't large enough. 669 * 670 * The out_value is modified only if a valid u64 value can be decoded. 671 */ 672int of_property_read_u64(const struct device_node *np, const char *propname, 673 u64 *out_value) 674{ 675 struct property *prop = of_find_property(np, propname, NULL); 676 677 if (!prop) 678 return -EINVAL; 679 if (!prop->value) 680 return -ENODATA; 681 if (sizeof(*out_value) > prop->length) 682 return -EOVERFLOW; 683 *out_value = of_read_number(prop->value, 2); 684 return 0; 685} 686EXPORT_SYMBOL_GPL(of_property_read_u64); 687 688/** 689 * of_property_read_string - Find and read a string from a property 690 * @np: device node from which the property value is to be read. 691 * @propname: name of the property to be searched. 692 * @out_string: pointer to null terminated return string, modified only if 693 * return value is 0. 694 * 695 * Search for a property in a device tree node and retrieve a null 696 * terminated string value (pointer to data, not a copy). Returns 0 on 697 * success, -EINVAL if the property does not exist, -ENODATA if property 698 * does not have a value, and -EILSEQ if the string is not null-terminated 699 * within the length of the property data. 700 * 701 * The out_string pointer is modified only if a valid string can be decoded. 702 */ 703int of_property_read_string(struct device_node *np, const char *propname, 704 const char **out_string) 705{ 706 struct property *prop = of_find_property(np, propname, NULL); 707 if (!prop) 708 return -EINVAL; 709 if (!prop->value) 710 return -ENODATA; 711 if (strnlen(prop->value, prop->length) >= prop->length) 712 return -EILSEQ; 713 *out_string = prop->value; 714 return 0; 715} 716EXPORT_SYMBOL_GPL(of_property_read_string); 717 718/** 719 * of_property_read_string_index - Find and read a string from a multiple 720 * strings property. 721 * @np: device node from which the property value is to be read. 722 * @propname: name of the property to be searched. 723 * @index: index of the string in the list of strings 724 * @out_string: pointer to null terminated return string, modified only if 725 * return value is 0. 726 * 727 * Search for a property in a device tree node and retrieve a null 728 * terminated string value (pointer to data, not a copy) in the list of strings 729 * contained in that property. 730 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if 731 * property does not have a value, and -EILSEQ if the string is not 732 * null-terminated within the length of the property data. 733 * 734 * The out_string pointer is modified only if a valid string can be decoded. 735 */ 736int of_property_read_string_index(struct device_node *np, const char *propname, 737 int index, const char **output) 738{ 739 struct property *prop = of_find_property(np, propname, NULL); 740 int i = 0; 741 size_t l = 0, total = 0; 742 const char *p; 743 744 if (!prop) 745 return -EINVAL; 746 if (!prop->value) 747 return -ENODATA; 748 if (strnlen(prop->value, prop->length) >= prop->length) 749 return -EILSEQ; 750 751 p = prop->value; 752 753 for (i = 0; total < prop->length; total += l, p += l) { 754 l = strlen(p) + 1; 755 if (i++ == index) { 756 *output = p; 757 return 0; 758 } 759 } 760 return -ENODATA; 761} 762EXPORT_SYMBOL_GPL(of_property_read_string_index); 763 764/** 765 * of_property_match_string() - Find string in a list and return index 766 * @np: pointer to node containing string list property 767 * @propname: string list property name 768 * @string: pointer to string to search for in string list 769 * 770 * This function searches a string list property and returns the index 771 * of a specific string value. 772 */ 773int of_property_match_string(struct device_node *np, const char *propname, 774 const char *string) 775{ 776 struct property *prop = of_find_property(np, propname, NULL); 777 size_t l; 778 int i; 779 const char *p, *end; 780 781 if (!prop) 782 return -EINVAL; 783 if (!prop->value) 784 return -ENODATA; 785 786 p = prop->value; 787 end = p + prop->length; 788 789 for (i = 0; p < end; i++, p += l) { 790 l = strlen(p) + 1; 791 if (p + l > end) 792 return -EILSEQ; 793 pr_debug("comparing %s with %s\n", string, p); 794 if (strcmp(string, p) == 0) 795 return i; /* Found it; return index */ 796 } 797 return -ENODATA; 798} 799EXPORT_SYMBOL_GPL(of_property_match_string); 800 801/** 802 * of_property_count_strings - Find and return the number of strings from a 803 * multiple strings property. 804 * @np: device node from which the property value is to be read. 805 * @propname: name of the property to be searched. 806 * 807 * Search for a property in a device tree node and retrieve the number of null 808 * terminated string contain in it. Returns the number of strings on 809 * success, -EINVAL if the property does not exist, -ENODATA if property 810 * does not have a value, and -EILSEQ if the string is not null-terminated 811 * within the length of the property data. 812 */ 813int of_property_count_strings(struct device_node *np, const char *propname) 814{ 815 struct property *prop = of_find_property(np, propname, NULL); 816 int i = 0; 817 size_t l = 0, total = 0; 818 const char *p; 819 820 if (!prop) 821 return -EINVAL; 822 if (!prop->value) 823 return -ENODATA; 824 if (strnlen(prop->value, prop->length) >= prop->length) 825 return -EILSEQ; 826 827 p = prop->value; 828 829 for (i = 0; total < prop->length; total += l, p += l, i++) 830 l = strlen(p) + 1; 831 832 return i; 833} 834EXPORT_SYMBOL_GPL(of_property_count_strings); 835 836/** 837 * of_parse_phandle - Resolve a phandle property to a device_node pointer 838 * @np: Pointer to device node holding phandle property 839 * @phandle_name: Name of property holding a phandle value 840 * @index: For properties holding a table of phandles, this is the index into 841 * the table 842 * 843 * Returns the device_node pointer with refcount incremented. Use 844 * of_node_put() on it when done. 845 */ 846struct device_node * 847of_parse_phandle(struct device_node *np, const char *phandle_name, int index) 848{ 849 const __be32 *phandle; 850 int size; 851 852 phandle = of_get_property(np, phandle_name, &size); 853 if ((!phandle) || (size < sizeof(*phandle) * (index + 1))) 854 return NULL; 855 856 return of_find_node_by_phandle(be32_to_cpup(phandle + index)); 857} 858EXPORT_SYMBOL(of_parse_phandle); 859 860/** 861 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list 862 * @np: pointer to a device tree node containing a list 863 * @list_name: property name that contains a list 864 * @cells_name: property name that specifies phandles' arguments count 865 * @index: index of a phandle to parse out 866 * @out_args: optional pointer to output arguments structure (will be filled) 867 * 868 * This function is useful to parse lists of phandles and their arguments. 869 * Returns 0 on success and fills out_args, on error returns appropriate 870 * errno value. 871 * 872 * Caller is responsible to call of_node_put() on the returned out_args->node 873 * pointer. 874 * 875 * Example: 876 * 877 * phandle1: node1 { 878 * #list-cells = <2>; 879 * } 880 * 881 * phandle2: node2 { 882 * #list-cells = <1>; 883 * } 884 * 885 * node3 { 886 * list = <&phandle1 1 2 &phandle2 3>; 887 * } 888 * 889 * To get a device_node of the `node2' node you may call this: 890 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args); 891 */ 892int of_parse_phandle_with_args(struct device_node *np, const char *list_name, 893 const char *cells_name, int index, 894 struct of_phandle_args *out_args) 895{ 896 const __be32 *list, *list_end; 897 int size, cur_index = 0; 898 uint32_t count = 0; 899 struct device_node *node = NULL; 900 phandle phandle; 901 902 /* Retrieve the phandle list property */ 903 list = of_get_property(np, list_name, &size); 904 if (!list) 905 return -EINVAL; 906 list_end = list + size / sizeof(*list); 907 908 /* Loop over the phandles until all the requested entry is found */ 909 while (list < list_end) { 910 count = 0; 911 912 /* 913 * If phandle is 0, then it is an empty entry with no 914 * arguments. Skip forward to the next entry. 915 */ 916 phandle = be32_to_cpup(list++); 917 if (phandle) { 918 /* 919 * Find the provider node and parse the #*-cells 920 * property to determine the argument length 921 */ 922 node = of_find_node_by_phandle(phandle); 923 if (!node) { 924 pr_err("%s: could not find phandle\n", 925 np->full_name); 926 break; 927 } 928 if (of_property_read_u32(node, cells_name, &count)) { 929 pr_err("%s: could not get %s for %s\n", 930 np->full_name, cells_name, 931 node->full_name); 932 break; 933 } 934 935 /* 936 * Make sure that the arguments actually fit in the 937 * remaining property data length 938 */ 939 if (list + count > list_end) { 940 pr_err("%s: arguments longer than property\n", 941 np->full_name); 942 break; 943 } 944 } 945 946 /* 947 * All of the error cases above bail out of the loop, so at 948 * this point, the parsing is successful. If the requested 949 * index matches, then fill the out_args structure and return, 950 * or return -ENOENT for an empty entry. 951 */ 952 if (cur_index == index) { 953 if (!phandle) 954 return -ENOENT; 955 956 if (out_args) { 957 int i; 958 if (WARN_ON(count > MAX_PHANDLE_ARGS)) 959 count = MAX_PHANDLE_ARGS; 960 out_args->np = node; 961 out_args->args_count = count; 962 for (i = 0; i < count; i++) 963 out_args->args[i] = be32_to_cpup(list++); 964 } 965 return 0; 966 } 967 968 of_node_put(node); 969 node = NULL; 970 list += count; 971 cur_index++; 972 } 973 974 /* Loop exited without finding a valid entry; return an error */ 975 if (node) 976 of_node_put(node); 977 return -EINVAL; 978} 979EXPORT_SYMBOL(of_parse_phandle_with_args); 980 981/** 982 * prom_add_property - Add a property to a node 983 */ 984int prom_add_property(struct device_node *np, struct property *prop) 985{ 986 struct property **next; 987 unsigned long flags; 988 989 prop->next = NULL; 990 write_lock_irqsave(&devtree_lock, flags); 991 next = &np->properties; 992 while (*next) { 993 if (strcmp(prop->name, (*next)->name) == 0) { 994 /* duplicate ! don't insert it */ 995 write_unlock_irqrestore(&devtree_lock, flags); 996 return -1; 997 } 998 next = &(*next)->next; 999 } 1000 *next = prop; 1001 write_unlock_irqrestore(&devtree_lock, flags); 1002 1003#ifdef CONFIG_PROC_DEVICETREE 1004 /* try to add to proc as well if it was initialized */ 1005 if (np->pde) 1006 proc_device_tree_add_prop(np->pde, prop); 1007#endif /* CONFIG_PROC_DEVICETREE */ 1008 1009 return 0; 1010} 1011 1012/** 1013 * prom_remove_property - Remove a property from a node. 1014 * 1015 * Note that we don't actually remove it, since we have given out 1016 * who-knows-how-many pointers to the data using get-property. 1017 * Instead we just move the property to the "dead properties" 1018 * list, so it won't be found any more. 1019 */ 1020int prom_remove_property(struct device_node *np, struct property *prop) 1021{ 1022 struct property **next; 1023 unsigned long flags; 1024 int found = 0; 1025 1026 write_lock_irqsave(&devtree_lock, flags); 1027 next = &np->properties; 1028 while (*next) { 1029 if (*next == prop) { 1030 /* found the node */ 1031 *next = prop->next; 1032 prop->next = np->deadprops; 1033 np->deadprops = prop; 1034 found = 1; 1035 break; 1036 } 1037 next = &(*next)->next; 1038 } 1039 write_unlock_irqrestore(&devtree_lock, flags); 1040 1041 if (!found) 1042 return -ENODEV; 1043 1044#ifdef CONFIG_PROC_DEVICETREE 1045 /* try to remove the proc node as well */ 1046 if (np->pde) 1047 proc_device_tree_remove_prop(np->pde, prop); 1048#endif /* CONFIG_PROC_DEVICETREE */ 1049 1050 return 0; 1051} 1052 1053/* 1054 * prom_update_property - Update a property in a node. 1055 * 1056 * Note that we don't actually remove it, since we have given out 1057 * who-knows-how-many pointers to the data using get-property. 1058 * Instead we just move the property to the "dead properties" list, 1059 * and add the new property to the property list 1060 */ 1061int prom_update_property(struct device_node *np, 1062 struct property *newprop, 1063 struct property *oldprop) 1064{ 1065 struct property **next; 1066 unsigned long flags; 1067 int found = 0; 1068 1069 write_lock_irqsave(&devtree_lock, flags); 1070 next = &np->properties; 1071 while (*next) { 1072 if (*next == oldprop) { 1073 /* found the node */ 1074 newprop->next = oldprop->next; 1075 *next = newprop; 1076 oldprop->next = np->deadprops; 1077 np->deadprops = oldprop; 1078 found = 1; 1079 break; 1080 } 1081 next = &(*next)->next; 1082 } 1083 write_unlock_irqrestore(&devtree_lock, flags); 1084 1085 if (!found) 1086 return -ENODEV; 1087 1088#ifdef CONFIG_PROC_DEVICETREE 1089 /* try to add to proc as well if it was initialized */ 1090 if (np->pde) 1091 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1092#endif /* CONFIG_PROC_DEVICETREE */ 1093 1094 return 0; 1095} 1096 1097#if defined(CONFIG_OF_DYNAMIC) 1098/* 1099 * Support for dynamic device trees. 1100 * 1101 * On some platforms, the device tree can be manipulated at runtime. 1102 * The routines in this section support adding, removing and changing 1103 * device tree nodes. 1104 */ 1105 1106/** 1107 * of_attach_node - Plug a device node into the tree and global list. 1108 */ 1109void of_attach_node(struct device_node *np) 1110{ 1111 unsigned long flags; 1112 1113 write_lock_irqsave(&devtree_lock, flags); 1114 np->sibling = np->parent->child; 1115 np->allnext = allnodes; 1116 np->parent->child = np; 1117 allnodes = np; 1118 write_unlock_irqrestore(&devtree_lock, flags); 1119} 1120 1121/** 1122 * of_detach_node - "Unplug" a node from the device tree. 1123 * 1124 * The caller must hold a reference to the node. The memory associated with 1125 * the node is not freed until its refcount goes to zero. 1126 */ 1127void of_detach_node(struct device_node *np) 1128{ 1129 struct device_node *parent; 1130 unsigned long flags; 1131 1132 write_lock_irqsave(&devtree_lock, flags); 1133 1134 parent = np->parent; 1135 if (!parent) 1136 goto out_unlock; 1137 1138 if (allnodes == np) 1139 allnodes = np->allnext; 1140 else { 1141 struct device_node *prev; 1142 for (prev = allnodes; 1143 prev->allnext != np; 1144 prev = prev->allnext) 1145 ; 1146 prev->allnext = np->allnext; 1147 } 1148 1149 if (parent->child == np) 1150 parent->child = np->sibling; 1151 else { 1152 struct device_node *prevsib; 1153 for (prevsib = np->parent->child; 1154 prevsib->sibling != np; 1155 prevsib = prevsib->sibling) 1156 ; 1157 prevsib->sibling = np->sibling; 1158 } 1159 1160 of_node_set_flag(np, OF_DETACHED); 1161 1162out_unlock: 1163 write_unlock_irqrestore(&devtree_lock, flags); 1164} 1165#endif /* defined(CONFIG_OF_DYNAMIC) */ 1166 1167static void of_alias_add(struct alias_prop *ap, struct device_node *np, 1168 int id, const char *stem, int stem_len) 1169{ 1170 ap->np = np; 1171 ap->id = id; 1172 strncpy(ap->stem, stem, stem_len); 1173 ap->stem[stem_len] = 0; 1174 list_add_tail(&ap->link, &aliases_lookup); 1175 pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n", 1176 ap->alias, ap->stem, ap->id, np ? np->full_name : NULL); 1177} 1178 1179/** 1180 * of_alias_scan - Scan all properties of 'aliases' node 1181 * 1182 * The function scans all the properties of 'aliases' node and populate 1183 * the the global lookup table with the properties. It returns the 1184 * number of alias_prop found, or error code in error case. 1185 * 1186 * @dt_alloc: An allocator that provides a virtual address to memory 1187 * for the resulting tree 1188 */ 1189void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)) 1190{ 1191 struct property *pp; 1192 1193 of_chosen = of_find_node_by_path("/chosen"); 1194 if (of_chosen == NULL) 1195 of_chosen = of_find_node_by_path("/chosen@0"); 1196 of_aliases = of_find_node_by_path("/aliases"); 1197 if (!of_aliases) 1198 return; 1199 1200 for_each_property_of_node(of_aliases, pp) { 1201 const char *start = pp->name; 1202 const char *end = start + strlen(start); 1203 struct device_node *np; 1204 struct alias_prop *ap; 1205 int id, len; 1206 1207 /* Skip those we do not want to proceed */ 1208 if (!strcmp(pp->name, "name") || 1209 !strcmp(pp->name, "phandle") || 1210 !strcmp(pp->name, "linux,phandle")) 1211 continue; 1212 1213 np = of_find_node_by_path(pp->value); 1214 if (!np) 1215 continue; 1216 1217 /* walk the alias backwards to extract the id and work out 1218 * the 'stem' string */ 1219 while (isdigit(*(end-1)) && end > start) 1220 end--; 1221 len = end - start; 1222 1223 if (kstrtoint(end, 10, &id) < 0) 1224 continue; 1225 1226 /* Allocate an alias_prop with enough space for the stem */ 1227 ap = dt_alloc(sizeof(*ap) + len + 1, 4); 1228 if (!ap) 1229 continue; 1230 ap->alias = start; 1231 of_alias_add(ap, np, id, start, len); 1232 } 1233} 1234 1235/** 1236 * of_alias_get_id - Get alias id for the given device_node 1237 * @np: Pointer to the given device_node 1238 * @stem: Alias stem of the given device_node 1239 * 1240 * The function travels the lookup table to get alias id for the given 1241 * device_node and alias stem. It returns the alias id if find it. 1242 */ 1243int of_alias_get_id(struct device_node *np, const char *stem) 1244{ 1245 struct alias_prop *app; 1246 int id = -ENODEV; 1247 1248 mutex_lock(&of_aliases_mutex); 1249 list_for_each_entry(app, &aliases_lookup, link) { 1250 if (strcmp(app->stem, stem) != 0) 1251 continue; 1252 1253 if (np == app->np) { 1254 id = app->id; 1255 break; 1256 } 1257 } 1258 mutex_unlock(&of_aliases_mutex); 1259 1260 return id; 1261} 1262EXPORT_SYMBOL_GPL(of_alias_get_id); 1263