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/console.h> 21#include <linux/ctype.h> 22#include <linux/cpu.h> 23#include <linux/module.h> 24#include <linux/of.h> 25#include <linux/of_graph.h> 26#include <linux/spinlock.h> 27#include <linux/slab.h> 28#include <linux/string.h> 29#include <linux/proc_fs.h> 30 31#include "of_private.h" 32 33LIST_HEAD(aliases_lookup); 34 35struct device_node *of_allnodes; 36EXPORT_SYMBOL(of_allnodes); 37struct device_node *of_chosen; 38struct device_node *of_aliases; 39struct device_node *of_stdout; 40 41struct kset *of_kset; 42 43/* 44 * Used to protect the of_aliases, to hold off addition of nodes to sysfs. 45 * This mutex must be held whenever modifications are being made to the 46 * device tree. The of_{attach,detach}_node() and 47 * of_{add,remove,update}_property() helpers make sure this happens. 48 */ 49DEFINE_MUTEX(of_mutex); 50 51/* use when traversing tree through the allnext, child, sibling, 52 * or parent members of struct device_node. 53 */ 54DEFINE_RAW_SPINLOCK(devtree_lock); 55 56int of_n_addr_cells(struct device_node *np) 57{ 58 const __be32 *ip; 59 60 do { 61 if (np->parent) 62 np = np->parent; 63 ip = of_get_property(np, "#address-cells", NULL); 64 if (ip) 65 return be32_to_cpup(ip); 66 } while (np->parent); 67 /* No #address-cells property for the root node */ 68 return OF_ROOT_NODE_ADDR_CELLS_DEFAULT; 69} 70EXPORT_SYMBOL(of_n_addr_cells); 71 72int of_n_size_cells(struct device_node *np) 73{ 74 const __be32 *ip; 75 76 do { 77 if (np->parent) 78 np = np->parent; 79 ip = of_get_property(np, "#size-cells", NULL); 80 if (ip) 81 return be32_to_cpup(ip); 82 } while (np->parent); 83 /* No #size-cells property for the root node */ 84 return OF_ROOT_NODE_SIZE_CELLS_DEFAULT; 85} 86EXPORT_SYMBOL(of_n_size_cells); 87 88#ifdef CONFIG_NUMA 89int __weak of_node_to_nid(struct device_node *np) 90{ 91 return numa_node_id(); 92} 93#endif 94 95#ifndef CONFIG_OF_DYNAMIC 96static void of_node_release(struct kobject *kobj) 97{ 98 /* Without CONFIG_OF_DYNAMIC, no nodes gets freed */ 99} 100#endif /* CONFIG_OF_DYNAMIC */ 101 102struct kobj_type of_node_ktype = { 103 .release = of_node_release, 104}; 105 106static ssize_t of_node_property_read(struct file *filp, struct kobject *kobj, 107 struct bin_attribute *bin_attr, char *buf, 108 loff_t offset, size_t count) 109{ 110 struct property *pp = container_of(bin_attr, struct property, attr); 111 return memory_read_from_buffer(buf, count, &offset, pp->value, pp->length); 112} 113 114static const char *safe_name(struct kobject *kobj, const char *orig_name) 115{ 116 const char *name = orig_name; 117 struct kernfs_node *kn; 118 int i = 0; 119 120 /* don't be a hero. After 16 tries give up */ 121 while (i < 16 && (kn = sysfs_get_dirent(kobj->sd, name))) { 122 sysfs_put(kn); 123 if (name != orig_name) 124 kfree(name); 125 name = kasprintf(GFP_KERNEL, "%s#%i", orig_name, ++i); 126 } 127 128 if (name != orig_name) 129 pr_warn("device-tree: Duplicate name in %s, renamed to \"%s\"\n", 130 kobject_name(kobj), name); 131 return name; 132} 133 134int __of_add_property_sysfs(struct device_node *np, struct property *pp) 135{ 136 int rc; 137 138 /* Important: Don't leak passwords */ 139 bool secure = strncmp(pp->name, "security-", 9) == 0; 140 141 if (!IS_ENABLED(CONFIG_SYSFS)) 142 return 0; 143 144 if (!of_kset || !of_node_is_attached(np)) 145 return 0; 146 147 sysfs_bin_attr_init(&pp->attr); 148 pp->attr.attr.name = safe_name(&np->kobj, pp->name); 149 pp->attr.attr.mode = secure ? S_IRUSR : S_IRUGO; 150 pp->attr.size = secure ? 0 : pp->length; 151 pp->attr.read = of_node_property_read; 152 153 rc = sysfs_create_bin_file(&np->kobj, &pp->attr); 154 WARN(rc, "error adding attribute %s to node %s\n", pp->name, np->full_name); 155 return rc; 156} 157 158int __of_attach_node_sysfs(struct device_node *np) 159{ 160 const char *name; 161 struct property *pp; 162 int rc; 163 164 if (!IS_ENABLED(CONFIG_SYSFS)) 165 return 0; 166 167 if (!of_kset) 168 return 0; 169 170 np->kobj.kset = of_kset; 171 if (!np->parent) { 172 /* Nodes without parents are new top level trees */ 173 rc = kobject_add(&np->kobj, NULL, "%s", 174 safe_name(&of_kset->kobj, "base")); 175 } else { 176 name = safe_name(&np->parent->kobj, kbasename(np->full_name)); 177 if (!name || !name[0]) 178 return -EINVAL; 179 180 rc = kobject_add(&np->kobj, &np->parent->kobj, "%s", name); 181 } 182 if (rc) 183 return rc; 184 185 for_each_property_of_node(np, pp) 186 __of_add_property_sysfs(np, pp); 187 188 return 0; 189} 190 191static int __init of_init(void) 192{ 193 struct device_node *np; 194 195 /* Create the kset, and register existing nodes */ 196 mutex_lock(&of_mutex); 197 of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj); 198 if (!of_kset) { 199 mutex_unlock(&of_mutex); 200 return -ENOMEM; 201 } 202 for_each_of_allnodes(np) 203 __of_attach_node_sysfs(np); 204 mutex_unlock(&of_mutex); 205 206 /* Symlink in /proc as required by userspace ABI */ 207 if (of_allnodes) 208 proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base"); 209 210 return 0; 211} 212core_initcall(of_init); 213 214static struct property *__of_find_property(const struct device_node *np, 215 const char *name, int *lenp) 216{ 217 struct property *pp; 218 219 if (!np) 220 return NULL; 221 222 for (pp = np->properties; pp; pp = pp->next) { 223 if (of_prop_cmp(pp->name, name) == 0) { 224 if (lenp) 225 *lenp = pp->length; 226 break; 227 } 228 } 229 230 return pp; 231} 232 233struct property *of_find_property(const struct device_node *np, 234 const char *name, 235 int *lenp) 236{ 237 struct property *pp; 238 unsigned long flags; 239 240 raw_spin_lock_irqsave(&devtree_lock, flags); 241 pp = __of_find_property(np, name, lenp); 242 raw_spin_unlock_irqrestore(&devtree_lock, flags); 243 244 return pp; 245} 246EXPORT_SYMBOL(of_find_property); 247 248/** 249 * of_find_all_nodes - Get next node in global list 250 * @prev: Previous node or NULL to start iteration 251 * of_node_put() will be called on it 252 * 253 * Returns a node pointer with refcount incremented, use 254 * of_node_put() on it when done. 255 */ 256struct device_node *of_find_all_nodes(struct device_node *prev) 257{ 258 struct device_node *np; 259 unsigned long flags; 260 261 raw_spin_lock_irqsave(&devtree_lock, flags); 262 np = prev ? prev->allnext : of_allnodes; 263 for (; np != NULL; np = np->allnext) 264 if (of_node_get(np)) 265 break; 266 of_node_put(prev); 267 raw_spin_unlock_irqrestore(&devtree_lock, flags); 268 return np; 269} 270EXPORT_SYMBOL(of_find_all_nodes); 271 272/* 273 * Find a property with a given name for a given node 274 * and return the value. 275 */ 276const void *__of_get_property(const struct device_node *np, 277 const char *name, int *lenp) 278{ 279 struct property *pp = __of_find_property(np, name, lenp); 280 281 return pp ? pp->value : NULL; 282} 283 284/* 285 * Find a property with a given name for a given node 286 * and return the value. 287 */ 288const void *of_get_property(const struct device_node *np, const char *name, 289 int *lenp) 290{ 291 struct property *pp = of_find_property(np, name, lenp); 292 293 return pp ? pp->value : NULL; 294} 295EXPORT_SYMBOL(of_get_property); 296 297/* 298 * arch_match_cpu_phys_id - Match the given logical CPU and physical id 299 * 300 * @cpu: logical cpu index of a core/thread 301 * @phys_id: physical identifier of a core/thread 302 * 303 * CPU logical to physical index mapping is architecture specific. 304 * However this __weak function provides a default match of physical 305 * id to logical cpu index. phys_id provided here is usually values read 306 * from the device tree which must match the hardware internal registers. 307 * 308 * Returns true if the physical identifier and the logical cpu index 309 * correspond to the same core/thread, false otherwise. 310 */ 311bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id) 312{ 313 return (u32)phys_id == cpu; 314} 315 316/** 317 * Checks if the given "prop_name" property holds the physical id of the 318 * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not 319 * NULL, local thread number within the core is returned in it. 320 */ 321static bool __of_find_n_match_cpu_property(struct device_node *cpun, 322 const char *prop_name, int cpu, unsigned int *thread) 323{ 324 const __be32 *cell; 325 int ac, prop_len, tid; 326 u64 hwid; 327 328 ac = of_n_addr_cells(cpun); 329 cell = of_get_property(cpun, prop_name, &prop_len); 330 if (!cell || !ac) 331 return false; 332 prop_len /= sizeof(*cell) * ac; 333 for (tid = 0; tid < prop_len; tid++) { 334 hwid = of_read_number(cell, ac); 335 if (arch_match_cpu_phys_id(cpu, hwid)) { 336 if (thread) 337 *thread = tid; 338 return true; 339 } 340 cell += ac; 341 } 342 return false; 343} 344 345/* 346 * arch_find_n_match_cpu_physical_id - See if the given device node is 347 * for the cpu corresponding to logical cpu 'cpu'. Return true if so, 348 * else false. If 'thread' is non-NULL, the local thread number within the 349 * core is returned in it. 350 */ 351bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun, 352 int cpu, unsigned int *thread) 353{ 354 /* Check for non-standard "ibm,ppc-interrupt-server#s" property 355 * for thread ids on PowerPC. If it doesn't exist fallback to 356 * standard "reg" property. 357 */ 358 if (IS_ENABLED(CONFIG_PPC) && 359 __of_find_n_match_cpu_property(cpun, 360 "ibm,ppc-interrupt-server#s", 361 cpu, thread)) 362 return true; 363 364 if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread)) 365 return true; 366 367 return false; 368} 369 370/** 371 * of_get_cpu_node - Get device node associated with the given logical CPU 372 * 373 * @cpu: CPU number(logical index) for which device node is required 374 * @thread: if not NULL, local thread number within the physical core is 375 * returned 376 * 377 * The main purpose of this function is to retrieve the device node for the 378 * given logical CPU index. It should be used to initialize the of_node in 379 * cpu device. Once of_node in cpu device is populated, all the further 380 * references can use that instead. 381 * 382 * CPU logical to physical index mapping is architecture specific and is built 383 * before booting secondary cores. This function uses arch_match_cpu_phys_id 384 * which can be overridden by architecture specific implementation. 385 * 386 * Returns a node pointer for the logical cpu if found, else NULL. 387 */ 388struct device_node *of_get_cpu_node(int cpu, unsigned int *thread) 389{ 390 struct device_node *cpun; 391 392 for_each_node_by_type(cpun, "cpu") { 393 if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread)) 394 return cpun; 395 } 396 return NULL; 397} 398EXPORT_SYMBOL(of_get_cpu_node); 399 400/** 401 * __of_device_is_compatible() - Check if the node matches given constraints 402 * @device: pointer to node 403 * @compat: required compatible string, NULL or "" for any match 404 * @type: required device_type value, NULL or "" for any match 405 * @name: required node name, NULL or "" for any match 406 * 407 * Checks if the given @compat, @type and @name strings match the 408 * properties of the given @device. A constraints can be skipped by 409 * passing NULL or an empty string as the constraint. 410 * 411 * Returns 0 for no match, and a positive integer on match. The return 412 * value is a relative score with larger values indicating better 413 * matches. The score is weighted for the most specific compatible value 414 * to get the highest score. Matching type is next, followed by matching 415 * name. Practically speaking, this results in the following priority 416 * order for matches: 417 * 418 * 1. specific compatible && type && name 419 * 2. specific compatible && type 420 * 3. specific compatible && name 421 * 4. specific compatible 422 * 5. general compatible && type && name 423 * 6. general compatible && type 424 * 7. general compatible && name 425 * 8. general compatible 426 * 9. type && name 427 * 10. type 428 * 11. name 429 */ 430static int __of_device_is_compatible(const struct device_node *device, 431 const char *compat, const char *type, const char *name) 432{ 433 struct property *prop; 434 const char *cp; 435 int index = 0, score = 0; 436 437 /* Compatible match has highest priority */ 438 if (compat && compat[0]) { 439 prop = __of_find_property(device, "compatible", NULL); 440 for (cp = of_prop_next_string(prop, NULL); cp; 441 cp = of_prop_next_string(prop, cp), index++) { 442 if (of_compat_cmp(cp, compat, strlen(compat)) == 0) { 443 score = INT_MAX/2 - (index << 2); 444 break; 445 } 446 } 447 if (!score) 448 return 0; 449 } 450 451 /* Matching type is better than matching name */ 452 if (type && type[0]) { 453 if (!device->type || of_node_cmp(type, device->type)) 454 return 0; 455 score += 2; 456 } 457 458 /* Matching name is a bit better than not */ 459 if (name && name[0]) { 460 if (!device->name || of_node_cmp(name, device->name)) 461 return 0; 462 score++; 463 } 464 465 return score; 466} 467 468/** Checks if the given "compat" string matches one of the strings in 469 * the device's "compatible" property 470 */ 471int of_device_is_compatible(const struct device_node *device, 472 const char *compat) 473{ 474 unsigned long flags; 475 int res; 476 477 raw_spin_lock_irqsave(&devtree_lock, flags); 478 res = __of_device_is_compatible(device, compat, NULL, NULL); 479 raw_spin_unlock_irqrestore(&devtree_lock, flags); 480 return res; 481} 482EXPORT_SYMBOL(of_device_is_compatible); 483 484/** 485 * of_machine_is_compatible - Test root of device tree for a given compatible value 486 * @compat: compatible string to look for in root node's compatible property. 487 * 488 * Returns true if the root node has the given value in its 489 * compatible property. 490 */ 491int of_machine_is_compatible(const char *compat) 492{ 493 struct device_node *root; 494 int rc = 0; 495 496 root = of_find_node_by_path("/"); 497 if (root) { 498 rc = of_device_is_compatible(root, compat); 499 of_node_put(root); 500 } 501 return rc; 502} 503EXPORT_SYMBOL(of_machine_is_compatible); 504 505/** 506 * __of_device_is_available - check if a device is available for use 507 * 508 * @device: Node to check for availability, with locks already held 509 * 510 * Returns 1 if the status property is absent or set to "okay" or "ok", 511 * 0 otherwise 512 */ 513static int __of_device_is_available(const struct device_node *device) 514{ 515 const char *status; 516 int statlen; 517 518 if (!device) 519 return 0; 520 521 status = __of_get_property(device, "status", &statlen); 522 if (status == NULL) 523 return 1; 524 525 if (statlen > 0) { 526 if (!strcmp(status, "okay") || !strcmp(status, "ok")) 527 return 1; 528 } 529 530 return 0; 531} 532 533/** 534 * of_device_is_available - check if a device is available for use 535 * 536 * @device: Node to check for availability 537 * 538 * Returns 1 if the status property is absent or set to "okay" or "ok", 539 * 0 otherwise 540 */ 541int of_device_is_available(const struct device_node *device) 542{ 543 unsigned long flags; 544 int res; 545 546 raw_spin_lock_irqsave(&devtree_lock, flags); 547 res = __of_device_is_available(device); 548 raw_spin_unlock_irqrestore(&devtree_lock, flags); 549 return res; 550 551} 552EXPORT_SYMBOL(of_device_is_available); 553 554/** 555 * of_get_parent - Get a node's parent if any 556 * @node: Node to get parent 557 * 558 * Returns a node pointer with refcount incremented, use 559 * of_node_put() on it when done. 560 */ 561struct device_node *of_get_parent(const struct device_node *node) 562{ 563 struct device_node *np; 564 unsigned long flags; 565 566 if (!node) 567 return NULL; 568 569 raw_spin_lock_irqsave(&devtree_lock, flags); 570 np = of_node_get(node->parent); 571 raw_spin_unlock_irqrestore(&devtree_lock, flags); 572 return np; 573} 574EXPORT_SYMBOL(of_get_parent); 575 576/** 577 * of_get_next_parent - Iterate to a node's parent 578 * @node: Node to get parent of 579 * 580 * This is like of_get_parent() except that it drops the 581 * refcount on the passed node, making it suitable for iterating 582 * through a node's parents. 583 * 584 * Returns a node pointer with refcount incremented, use 585 * of_node_put() on it when done. 586 */ 587struct device_node *of_get_next_parent(struct device_node *node) 588{ 589 struct device_node *parent; 590 unsigned long flags; 591 592 if (!node) 593 return NULL; 594 595 raw_spin_lock_irqsave(&devtree_lock, flags); 596 parent = of_node_get(node->parent); 597 of_node_put(node); 598 raw_spin_unlock_irqrestore(&devtree_lock, flags); 599 return parent; 600} 601EXPORT_SYMBOL(of_get_next_parent); 602 603static struct device_node *__of_get_next_child(const struct device_node *node, 604 struct device_node *prev) 605{ 606 struct device_node *next; 607 608 if (!node) 609 return NULL; 610 611 next = prev ? prev->sibling : node->child; 612 for (; next; next = next->sibling) 613 if (of_node_get(next)) 614 break; 615 of_node_put(prev); 616 return next; 617} 618#define __for_each_child_of_node(parent, child) \ 619 for (child = __of_get_next_child(parent, NULL); child != NULL; \ 620 child = __of_get_next_child(parent, child)) 621 622/** 623 * of_get_next_child - Iterate a node childs 624 * @node: parent node 625 * @prev: previous child of the parent node, or NULL to get first 626 * 627 * Returns a node pointer with refcount incremented, use 628 * of_node_put() on it when done. 629 */ 630struct device_node *of_get_next_child(const struct device_node *node, 631 struct device_node *prev) 632{ 633 struct device_node *next; 634 unsigned long flags; 635 636 raw_spin_lock_irqsave(&devtree_lock, flags); 637 next = __of_get_next_child(node, prev); 638 raw_spin_unlock_irqrestore(&devtree_lock, flags); 639 return next; 640} 641EXPORT_SYMBOL(of_get_next_child); 642 643/** 644 * of_get_next_available_child - Find the next available child node 645 * @node: parent node 646 * @prev: previous child of the parent node, or NULL to get first 647 * 648 * This function is like of_get_next_child(), except that it 649 * automatically skips any disabled nodes (i.e. status = "disabled"). 650 */ 651struct device_node *of_get_next_available_child(const struct device_node *node, 652 struct device_node *prev) 653{ 654 struct device_node *next; 655 unsigned long flags; 656 657 if (!node) 658 return NULL; 659 660 raw_spin_lock_irqsave(&devtree_lock, flags); 661 next = prev ? prev->sibling : node->child; 662 for (; next; next = next->sibling) { 663 if (!__of_device_is_available(next)) 664 continue; 665 if (of_node_get(next)) 666 break; 667 } 668 of_node_put(prev); 669 raw_spin_unlock_irqrestore(&devtree_lock, flags); 670 return next; 671} 672EXPORT_SYMBOL(of_get_next_available_child); 673 674/** 675 * of_get_child_by_name - Find the child node by name for a given parent 676 * @node: parent node 677 * @name: child name to look for. 678 * 679 * This function looks for child node for given matching name 680 * 681 * Returns a node pointer if found, with refcount incremented, use 682 * of_node_put() on it when done. 683 * Returns NULL if node is not found. 684 */ 685struct device_node *of_get_child_by_name(const struct device_node *node, 686 const char *name) 687{ 688 struct device_node *child; 689 690 for_each_child_of_node(node, child) 691 if (child->name && (of_node_cmp(child->name, name) == 0)) 692 break; 693 return child; 694} 695EXPORT_SYMBOL(of_get_child_by_name); 696 697static struct device_node *__of_find_node_by_path(struct device_node *parent, 698 const char *path) 699{ 700 struct device_node *child; 701 int len = strchrnul(path, '/') - path; 702 703 if (!len) 704 return NULL; 705 706 __for_each_child_of_node(parent, child) { 707 const char *name = strrchr(child->full_name, '/'); 708 if (WARN(!name, "malformed device_node %s\n", child->full_name)) 709 continue; 710 name++; 711 if (strncmp(path, name, len) == 0 && (strlen(name) == len)) 712 return child; 713 } 714 return NULL; 715} 716 717/** 718 * of_find_node_by_path - Find a node matching a full OF path 719 * @path: Either the full path to match, or if the path does not 720 * start with '/', the name of a property of the /aliases 721 * node (an alias). In the case of an alias, the node 722 * matching the alias' value will be returned. 723 * 724 * Valid paths: 725 * /foo/bar Full path 726 * foo Valid alias 727 * foo/bar Valid alias + relative path 728 * 729 * Returns a node pointer with refcount incremented, use 730 * of_node_put() on it when done. 731 */ 732struct device_node *of_find_node_by_path(const char *path) 733{ 734 struct device_node *np = NULL; 735 struct property *pp; 736 unsigned long flags; 737 738 if (strcmp(path, "/") == 0) 739 return of_node_get(of_allnodes); 740 741 /* The path could begin with an alias */ 742 if (*path != '/') { 743 char *p = strchrnul(path, '/'); 744 int len = p - path; 745 746 /* of_aliases must not be NULL */ 747 if (!of_aliases) 748 return NULL; 749 750 for_each_property_of_node(of_aliases, pp) { 751 if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) { 752 np = of_find_node_by_path(pp->value); 753 break; 754 } 755 } 756 if (!np) 757 return NULL; 758 path = p; 759 } 760 761 /* Step down the tree matching path components */ 762 raw_spin_lock_irqsave(&devtree_lock, flags); 763 if (!np) 764 np = of_node_get(of_allnodes); 765 while (np && *path == '/') { 766 path++; /* Increment past '/' delimiter */ 767 np = __of_find_node_by_path(np, path); 768 path = strchrnul(path, '/'); 769 } 770 raw_spin_unlock_irqrestore(&devtree_lock, flags); 771 return np; 772} 773EXPORT_SYMBOL(of_find_node_by_path); 774 775/** 776 * of_find_node_by_name - Find a node by its "name" property 777 * @from: The node to start searching from or NULL, the node 778 * you pass will not be searched, only the next one 779 * will; typically, you pass what the previous call 780 * returned. of_node_put() will be called on it 781 * @name: The name string to match against 782 * 783 * Returns a node pointer with refcount incremented, use 784 * of_node_put() on it when done. 785 */ 786struct device_node *of_find_node_by_name(struct device_node *from, 787 const char *name) 788{ 789 struct device_node *np; 790 unsigned long flags; 791 792 raw_spin_lock_irqsave(&devtree_lock, flags); 793 np = from ? from->allnext : of_allnodes; 794 for (; np; np = np->allnext) 795 if (np->name && (of_node_cmp(np->name, name) == 0) 796 && of_node_get(np)) 797 break; 798 of_node_put(from); 799 raw_spin_unlock_irqrestore(&devtree_lock, flags); 800 return np; 801} 802EXPORT_SYMBOL(of_find_node_by_name); 803 804/** 805 * of_find_node_by_type - Find a node by its "device_type" property 806 * @from: The node to start searching from, or NULL to start searching 807 * the entire device tree. The node you pass will not be 808 * searched, only the next one will; typically, you pass 809 * what the previous call returned. of_node_put() will be 810 * called on from for you. 811 * @type: The type string to match against 812 * 813 * Returns a node pointer with refcount incremented, use 814 * of_node_put() on it when done. 815 */ 816struct device_node *of_find_node_by_type(struct device_node *from, 817 const char *type) 818{ 819 struct device_node *np; 820 unsigned long flags; 821 822 raw_spin_lock_irqsave(&devtree_lock, flags); 823 np = from ? from->allnext : of_allnodes; 824 for (; np; np = np->allnext) 825 if (np->type && (of_node_cmp(np->type, type) == 0) 826 && of_node_get(np)) 827 break; 828 of_node_put(from); 829 raw_spin_unlock_irqrestore(&devtree_lock, flags); 830 return np; 831} 832EXPORT_SYMBOL(of_find_node_by_type); 833 834/** 835 * of_find_compatible_node - Find a node based on type and one of the 836 * tokens in its "compatible" property 837 * @from: The node to start searching from or NULL, the node 838 * you pass will not be searched, only the next one 839 * will; typically, you pass what the previous call 840 * returned. of_node_put() will be called on it 841 * @type: The type string to match "device_type" or NULL to ignore 842 * @compatible: The string to match to one of the tokens in the device 843 * "compatible" list. 844 * 845 * Returns a node pointer with refcount incremented, use 846 * of_node_put() on it when done. 847 */ 848struct device_node *of_find_compatible_node(struct device_node *from, 849 const char *type, const char *compatible) 850{ 851 struct device_node *np; 852 unsigned long flags; 853 854 raw_spin_lock_irqsave(&devtree_lock, flags); 855 np = from ? from->allnext : of_allnodes; 856 for (; np; np = np->allnext) { 857 if (__of_device_is_compatible(np, compatible, type, NULL) && 858 of_node_get(np)) 859 break; 860 } 861 of_node_put(from); 862 raw_spin_unlock_irqrestore(&devtree_lock, flags); 863 return np; 864} 865EXPORT_SYMBOL(of_find_compatible_node); 866 867/** 868 * of_find_node_with_property - Find a node which has a property with 869 * the given name. 870 * @from: The node to start searching from or NULL, the node 871 * you pass will not be searched, only the next one 872 * will; typically, you pass what the previous call 873 * returned. of_node_put() will be called on it 874 * @prop_name: The name of the property to look for. 875 * 876 * Returns a node pointer with refcount incremented, use 877 * of_node_put() on it when done. 878 */ 879struct device_node *of_find_node_with_property(struct device_node *from, 880 const char *prop_name) 881{ 882 struct device_node *np; 883 struct property *pp; 884 unsigned long flags; 885 886 raw_spin_lock_irqsave(&devtree_lock, flags); 887 np = from ? from->allnext : of_allnodes; 888 for (; np; np = np->allnext) { 889 for (pp = np->properties; pp; pp = pp->next) { 890 if (of_prop_cmp(pp->name, prop_name) == 0) { 891 of_node_get(np); 892 goto out; 893 } 894 } 895 } 896out: 897 of_node_put(from); 898 raw_spin_unlock_irqrestore(&devtree_lock, flags); 899 return np; 900} 901EXPORT_SYMBOL(of_find_node_with_property); 902 903static 904const struct of_device_id *__of_match_node(const struct of_device_id *matches, 905 const struct device_node *node) 906{ 907 const struct of_device_id *best_match = NULL; 908 int score, best_score = 0; 909 910 if (!matches) 911 return NULL; 912 913 for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) { 914 score = __of_device_is_compatible(node, matches->compatible, 915 matches->type, matches->name); 916 if (score > best_score) { 917 best_match = matches; 918 best_score = score; 919 } 920 } 921 922 return best_match; 923} 924 925/** 926 * of_match_node - Tell if an device_node has a matching of_match structure 927 * @matches: array of of device match structures to search in 928 * @node: the of device structure to match against 929 * 930 * Low level utility function used by device matching. 931 */ 932const struct of_device_id *of_match_node(const struct of_device_id *matches, 933 const struct device_node *node) 934{ 935 const struct of_device_id *match; 936 unsigned long flags; 937 938 raw_spin_lock_irqsave(&devtree_lock, flags); 939 match = __of_match_node(matches, node); 940 raw_spin_unlock_irqrestore(&devtree_lock, flags); 941 return match; 942} 943EXPORT_SYMBOL(of_match_node); 944 945/** 946 * of_find_matching_node_and_match - Find a node based on an of_device_id 947 * match table. 948 * @from: The node to start searching from or NULL, the node 949 * you pass will not be searched, only the next one 950 * will; typically, you pass what the previous call 951 * returned. of_node_put() will be called on it 952 * @matches: array of of device match structures to search in 953 * @match Updated to point at the matches entry which matched 954 * 955 * Returns a node pointer with refcount incremented, use 956 * of_node_put() on it when done. 957 */ 958struct device_node *of_find_matching_node_and_match(struct device_node *from, 959 const struct of_device_id *matches, 960 const struct of_device_id **match) 961{ 962 struct device_node *np; 963 const struct of_device_id *m; 964 unsigned long flags; 965 966 if (match) 967 *match = NULL; 968 969 raw_spin_lock_irqsave(&devtree_lock, flags); 970 np = from ? from->allnext : of_allnodes; 971 for (; np; np = np->allnext) { 972 m = __of_match_node(matches, np); 973 if (m && of_node_get(np)) { 974 if (match) 975 *match = m; 976 break; 977 } 978 } 979 of_node_put(from); 980 raw_spin_unlock_irqrestore(&devtree_lock, flags); 981 return np; 982} 983EXPORT_SYMBOL(of_find_matching_node_and_match); 984 985/** 986 * of_modalias_node - Lookup appropriate modalias for a device node 987 * @node: pointer to a device tree node 988 * @modalias: Pointer to buffer that modalias value will be copied into 989 * @len: Length of modalias value 990 * 991 * Based on the value of the compatible property, this routine will attempt 992 * to choose an appropriate modalias value for a particular device tree node. 993 * It does this by stripping the manufacturer prefix (as delimited by a ',') 994 * from the first entry in the compatible list property. 995 * 996 * This routine returns 0 on success, <0 on failure. 997 */ 998int of_modalias_node(struct device_node *node, char *modalias, int len) 999{ 1000 const char *compatible, *p; 1001 int cplen; 1002 1003 compatible = of_get_property(node, "compatible", &cplen); 1004 if (!compatible || strlen(compatible) > cplen) 1005 return -ENODEV; 1006 p = strchr(compatible, ','); 1007 strlcpy(modalias, p ? p + 1 : compatible, len); 1008 return 0; 1009} 1010EXPORT_SYMBOL_GPL(of_modalias_node); 1011 1012/** 1013 * of_find_node_by_phandle - Find a node given a phandle 1014 * @handle: phandle of the node to find 1015 * 1016 * Returns a node pointer with refcount incremented, use 1017 * of_node_put() on it when done. 1018 */ 1019struct device_node *of_find_node_by_phandle(phandle handle) 1020{ 1021 struct device_node *np; 1022 unsigned long flags; 1023 1024 if (!handle) 1025 return NULL; 1026 1027 raw_spin_lock_irqsave(&devtree_lock, flags); 1028 for (np = of_allnodes; np; np = np->allnext) 1029 if (np->phandle == handle) 1030 break; 1031 of_node_get(np); 1032 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1033 return np; 1034} 1035EXPORT_SYMBOL(of_find_node_by_phandle); 1036 1037/** 1038 * of_property_count_elems_of_size - Count the number of elements in a property 1039 * 1040 * @np: device node from which the property value is to be read. 1041 * @propname: name of the property to be searched. 1042 * @elem_size: size of the individual element 1043 * 1044 * Search for a property in a device node and count the number of elements of 1045 * size elem_size in it. Returns number of elements on sucess, -EINVAL if the 1046 * property does not exist or its length does not match a multiple of elem_size 1047 * and -ENODATA if the property does not have a value. 1048 */ 1049int of_property_count_elems_of_size(const struct device_node *np, 1050 const char *propname, int elem_size) 1051{ 1052 struct property *prop = of_find_property(np, propname, NULL); 1053 1054 if (!prop) 1055 return -EINVAL; 1056 if (!prop->value) 1057 return -ENODATA; 1058 1059 if (prop->length % elem_size != 0) { 1060 pr_err("size of %s in node %s is not a multiple of %d\n", 1061 propname, np->full_name, elem_size); 1062 return -EINVAL; 1063 } 1064 1065 return prop->length / elem_size; 1066} 1067EXPORT_SYMBOL_GPL(of_property_count_elems_of_size); 1068 1069/** 1070 * of_find_property_value_of_size 1071 * 1072 * @np: device node from which the property value is to be read. 1073 * @propname: name of the property to be searched. 1074 * @len: requested length of property value 1075 * 1076 * Search for a property in a device node and valid the requested size. 1077 * Returns the property value on success, -EINVAL if the property does not 1078 * exist, -ENODATA if property does not have a value, and -EOVERFLOW if the 1079 * property data isn't large enough. 1080 * 1081 */ 1082static void *of_find_property_value_of_size(const struct device_node *np, 1083 const char *propname, u32 len) 1084{ 1085 struct property *prop = of_find_property(np, propname, NULL); 1086 1087 if (!prop) 1088 return ERR_PTR(-EINVAL); 1089 if (!prop->value) 1090 return ERR_PTR(-ENODATA); 1091 if (len > prop->length) 1092 return ERR_PTR(-EOVERFLOW); 1093 1094 return prop->value; 1095} 1096 1097/** 1098 * of_property_read_u32_index - Find and read a u32 from a multi-value property. 1099 * 1100 * @np: device node from which the property value is to be read. 1101 * @propname: name of the property to be searched. 1102 * @index: index of the u32 in the list of values 1103 * @out_value: pointer to return value, modified only if no error. 1104 * 1105 * Search for a property in a device node and read nth 32-bit value from 1106 * it. Returns 0 on success, -EINVAL if the property does not exist, 1107 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1108 * property data isn't large enough. 1109 * 1110 * The out_value is modified only if a valid u32 value can be decoded. 1111 */ 1112int of_property_read_u32_index(const struct device_node *np, 1113 const char *propname, 1114 u32 index, u32 *out_value) 1115{ 1116 const u32 *val = of_find_property_value_of_size(np, propname, 1117 ((index + 1) * sizeof(*out_value))); 1118 1119 if (IS_ERR(val)) 1120 return PTR_ERR(val); 1121 1122 *out_value = be32_to_cpup(((__be32 *)val) + index); 1123 return 0; 1124} 1125EXPORT_SYMBOL_GPL(of_property_read_u32_index); 1126 1127/** 1128 * of_property_read_u8_array - Find and read an array of u8 from a property. 1129 * 1130 * @np: device node from which the property value is to be read. 1131 * @propname: name of the property to be searched. 1132 * @out_values: pointer to return value, modified only if return value is 0. 1133 * @sz: number of array elements to read 1134 * 1135 * Search for a property in a device node and read 8-bit value(s) from 1136 * it. Returns 0 on success, -EINVAL if the property does not exist, 1137 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1138 * property data isn't large enough. 1139 * 1140 * dts entry of array should be like: 1141 * property = /bits/ 8 <0x50 0x60 0x70>; 1142 * 1143 * The out_values is modified only if a valid u8 value can be decoded. 1144 */ 1145int of_property_read_u8_array(const struct device_node *np, 1146 const char *propname, u8 *out_values, size_t sz) 1147{ 1148 const u8 *val = of_find_property_value_of_size(np, propname, 1149 (sz * sizeof(*out_values))); 1150 1151 if (IS_ERR(val)) 1152 return PTR_ERR(val); 1153 1154 while (sz--) 1155 *out_values++ = *val++; 1156 return 0; 1157} 1158EXPORT_SYMBOL_GPL(of_property_read_u8_array); 1159 1160/** 1161 * of_property_read_u16_array - Find and read an array of u16 from a property. 1162 * 1163 * @np: device node from which the property value is to be read. 1164 * @propname: name of the property to be searched. 1165 * @out_values: pointer to return value, modified only if return value is 0. 1166 * @sz: number of array elements to read 1167 * 1168 * Search for a property in a device node and read 16-bit value(s) from 1169 * it. Returns 0 on success, -EINVAL if the property does not exist, 1170 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1171 * property data isn't large enough. 1172 * 1173 * dts entry of array should be like: 1174 * property = /bits/ 16 <0x5000 0x6000 0x7000>; 1175 * 1176 * The out_values is modified only if a valid u16 value can be decoded. 1177 */ 1178int of_property_read_u16_array(const struct device_node *np, 1179 const char *propname, u16 *out_values, size_t sz) 1180{ 1181 const __be16 *val = of_find_property_value_of_size(np, propname, 1182 (sz * sizeof(*out_values))); 1183 1184 if (IS_ERR(val)) 1185 return PTR_ERR(val); 1186 1187 while (sz--) 1188 *out_values++ = be16_to_cpup(val++); 1189 return 0; 1190} 1191EXPORT_SYMBOL_GPL(of_property_read_u16_array); 1192 1193/** 1194 * of_property_read_u32_array - Find and read an array of 32 bit integers 1195 * from a property. 1196 * 1197 * @np: device node from which the property value is to be read. 1198 * @propname: name of the property to be searched. 1199 * @out_values: pointer to return value, modified only if return value is 0. 1200 * @sz: number of array elements to read 1201 * 1202 * Search for a property in a device node and read 32-bit value(s) from 1203 * it. Returns 0 on success, -EINVAL if the property does not exist, 1204 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1205 * property data isn't large enough. 1206 * 1207 * The out_values is modified only if a valid u32 value can be decoded. 1208 */ 1209int of_property_read_u32_array(const struct device_node *np, 1210 const char *propname, u32 *out_values, 1211 size_t sz) 1212{ 1213 const __be32 *val = of_find_property_value_of_size(np, propname, 1214 (sz * sizeof(*out_values))); 1215 1216 if (IS_ERR(val)) 1217 return PTR_ERR(val); 1218 1219 while (sz--) 1220 *out_values++ = be32_to_cpup(val++); 1221 return 0; 1222} 1223EXPORT_SYMBOL_GPL(of_property_read_u32_array); 1224 1225/** 1226 * of_property_read_u64 - Find and read a 64 bit integer from a property 1227 * @np: device node from which the property value is to be read. 1228 * @propname: name of the property to be searched. 1229 * @out_value: pointer to return value, modified only if return value is 0. 1230 * 1231 * Search for a property in a device node and read a 64-bit value from 1232 * it. Returns 0 on success, -EINVAL if the property does not exist, 1233 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1234 * property data isn't large enough. 1235 * 1236 * The out_value is modified only if a valid u64 value can be decoded. 1237 */ 1238int of_property_read_u64(const struct device_node *np, const char *propname, 1239 u64 *out_value) 1240{ 1241 const __be32 *val = of_find_property_value_of_size(np, propname, 1242 sizeof(*out_value)); 1243 1244 if (IS_ERR(val)) 1245 return PTR_ERR(val); 1246 1247 *out_value = of_read_number(val, 2); 1248 return 0; 1249} 1250EXPORT_SYMBOL_GPL(of_property_read_u64); 1251 1252/** 1253 * of_property_read_string - Find and read a string from a property 1254 * @np: device node from which the property value is to be read. 1255 * @propname: name of the property to be searched. 1256 * @out_string: pointer to null terminated return string, modified only if 1257 * return value is 0. 1258 * 1259 * Search for a property in a device tree node and retrieve a null 1260 * terminated string value (pointer to data, not a copy). Returns 0 on 1261 * success, -EINVAL if the property does not exist, -ENODATA if property 1262 * does not have a value, and -EILSEQ if the string is not null-terminated 1263 * within the length of the property data. 1264 * 1265 * The out_string pointer is modified only if a valid string can be decoded. 1266 */ 1267int of_property_read_string(struct device_node *np, const char *propname, 1268 const char **out_string) 1269{ 1270 struct property *prop = of_find_property(np, propname, NULL); 1271 if (!prop) 1272 return -EINVAL; 1273 if (!prop->value) 1274 return -ENODATA; 1275 if (strnlen(prop->value, prop->length) >= prop->length) 1276 return -EILSEQ; 1277 *out_string = prop->value; 1278 return 0; 1279} 1280EXPORT_SYMBOL_GPL(of_property_read_string); 1281 1282/** 1283 * of_property_match_string() - Find string in a list and return index 1284 * @np: pointer to node containing string list property 1285 * @propname: string list property name 1286 * @string: pointer to string to search for in string list 1287 * 1288 * This function searches a string list property and returns the index 1289 * of a specific string value. 1290 */ 1291int of_property_match_string(struct device_node *np, const char *propname, 1292 const char *string) 1293{ 1294 struct property *prop = of_find_property(np, propname, NULL); 1295 size_t l; 1296 int i; 1297 const char *p, *end; 1298 1299 if (!prop) 1300 return -EINVAL; 1301 if (!prop->value) 1302 return -ENODATA; 1303 1304 p = prop->value; 1305 end = p + prop->length; 1306 1307 for (i = 0; p < end; i++, p += l) { 1308 l = strnlen(p, end - p) + 1; 1309 if (p + l > end) 1310 return -EILSEQ; 1311 pr_debug("comparing %s with %s\n", string, p); 1312 if (strcmp(string, p) == 0) 1313 return i; /* Found it; return index */ 1314 } 1315 return -ENODATA; 1316} 1317EXPORT_SYMBOL_GPL(of_property_match_string); 1318 1319/** 1320 * of_property_read_string_util() - Utility helper for parsing string properties 1321 * @np: device node from which the property value is to be read. 1322 * @propname: name of the property to be searched. 1323 * @out_strs: output array of string pointers. 1324 * @sz: number of array elements to read. 1325 * @skip: Number of strings to skip over at beginning of list. 1326 * 1327 * Don't call this function directly. It is a utility helper for the 1328 * of_property_read_string*() family of functions. 1329 */ 1330int of_property_read_string_helper(struct device_node *np, const char *propname, 1331 const char **out_strs, size_t sz, int skip) 1332{ 1333 struct property *prop = of_find_property(np, propname, NULL); 1334 int l = 0, i = 0; 1335 const char *p, *end; 1336 1337 if (!prop) 1338 return -EINVAL; 1339 if (!prop->value) 1340 return -ENODATA; 1341 p = prop->value; 1342 end = p + prop->length; 1343 1344 for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) { 1345 l = strnlen(p, end - p) + 1; 1346 if (p + l > end) 1347 return -EILSEQ; 1348 if (out_strs && i >= skip) 1349 *out_strs++ = p; 1350 } 1351 i -= skip; 1352 return i <= 0 ? -ENODATA : i; 1353} 1354EXPORT_SYMBOL_GPL(of_property_read_string_helper); 1355 1356void of_print_phandle_args(const char *msg, const struct of_phandle_args *args) 1357{ 1358 int i; 1359 printk("%s %s", msg, of_node_full_name(args->np)); 1360 for (i = 0; i < args->args_count; i++) 1361 printk(i ? ",%08x" : ":%08x", args->args[i]); 1362 printk("\n"); 1363} 1364 1365static int __of_parse_phandle_with_args(const struct device_node *np, 1366 const char *list_name, 1367 const char *cells_name, 1368 int cell_count, int index, 1369 struct of_phandle_args *out_args) 1370{ 1371 const __be32 *list, *list_end; 1372 int rc = 0, size, cur_index = 0; 1373 uint32_t count = 0; 1374 struct device_node *node = NULL; 1375 phandle phandle; 1376 1377 /* Retrieve the phandle list property */ 1378 list = of_get_property(np, list_name, &size); 1379 if (!list) 1380 return -ENOENT; 1381 list_end = list + size / sizeof(*list); 1382 1383 /* Loop over the phandles until all the requested entry is found */ 1384 while (list < list_end) { 1385 rc = -EINVAL; 1386 count = 0; 1387 1388 /* 1389 * If phandle is 0, then it is an empty entry with no 1390 * arguments. Skip forward to the next entry. 1391 */ 1392 phandle = be32_to_cpup(list++); 1393 if (phandle) { 1394 /* 1395 * Find the provider node and parse the #*-cells 1396 * property to determine the argument length. 1397 * 1398 * This is not needed if the cell count is hard-coded 1399 * (i.e. cells_name not set, but cell_count is set), 1400 * except when we're going to return the found node 1401 * below. 1402 */ 1403 if (cells_name || cur_index == index) { 1404 node = of_find_node_by_phandle(phandle); 1405 if (!node) { 1406 pr_err("%s: could not find phandle\n", 1407 np->full_name); 1408 goto err; 1409 } 1410 } 1411 1412 if (cells_name) { 1413 if (of_property_read_u32(node, cells_name, 1414 &count)) { 1415 pr_err("%s: could not get %s for %s\n", 1416 np->full_name, cells_name, 1417 node->full_name); 1418 goto err; 1419 } 1420 } else { 1421 count = cell_count; 1422 } 1423 1424 /* 1425 * Make sure that the arguments actually fit in the 1426 * remaining property data length 1427 */ 1428 if (list + count > list_end) { 1429 pr_err("%s: arguments longer than property\n", 1430 np->full_name); 1431 goto err; 1432 } 1433 } 1434 1435 /* 1436 * All of the error cases above bail out of the loop, so at 1437 * this point, the parsing is successful. If the requested 1438 * index matches, then fill the out_args structure and return, 1439 * or return -ENOENT for an empty entry. 1440 */ 1441 rc = -ENOENT; 1442 if (cur_index == index) { 1443 if (!phandle) 1444 goto err; 1445 1446 if (out_args) { 1447 int i; 1448 if (WARN_ON(count > MAX_PHANDLE_ARGS)) 1449 count = MAX_PHANDLE_ARGS; 1450 out_args->np = node; 1451 out_args->args_count = count; 1452 for (i = 0; i < count; i++) 1453 out_args->args[i] = be32_to_cpup(list++); 1454 } else { 1455 of_node_put(node); 1456 } 1457 1458 /* Found it! return success */ 1459 return 0; 1460 } 1461 1462 of_node_put(node); 1463 node = NULL; 1464 list += count; 1465 cur_index++; 1466 } 1467 1468 /* 1469 * Unlock node before returning result; will be one of: 1470 * -ENOENT : index is for empty phandle 1471 * -EINVAL : parsing error on data 1472 * [1..n] : Number of phandle (count mode; when index = -1) 1473 */ 1474 rc = index < 0 ? cur_index : -ENOENT; 1475 err: 1476 if (node) 1477 of_node_put(node); 1478 return rc; 1479} 1480 1481/** 1482 * of_parse_phandle - Resolve a phandle property to a device_node pointer 1483 * @np: Pointer to device node holding phandle property 1484 * @phandle_name: Name of property holding a phandle value 1485 * @index: For properties holding a table of phandles, this is the index into 1486 * the table 1487 * 1488 * Returns the device_node pointer with refcount incremented. Use 1489 * of_node_put() on it when done. 1490 */ 1491struct device_node *of_parse_phandle(const struct device_node *np, 1492 const char *phandle_name, int index) 1493{ 1494 struct of_phandle_args args; 1495 1496 if (index < 0) 1497 return NULL; 1498 1499 if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0, 1500 index, &args)) 1501 return NULL; 1502 1503 return args.np; 1504} 1505EXPORT_SYMBOL(of_parse_phandle); 1506 1507/** 1508 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list 1509 * @np: pointer to a device tree node containing a list 1510 * @list_name: property name that contains a list 1511 * @cells_name: property name that specifies phandles' arguments count 1512 * @index: index of a phandle to parse out 1513 * @out_args: optional pointer to output arguments structure (will be filled) 1514 * 1515 * This function is useful to parse lists of phandles and their arguments. 1516 * Returns 0 on success and fills out_args, on error returns appropriate 1517 * errno value. 1518 * 1519 * Caller is responsible to call of_node_put() on the returned out_args->node 1520 * pointer. 1521 * 1522 * Example: 1523 * 1524 * phandle1: node1 { 1525 * #list-cells = <2>; 1526 * } 1527 * 1528 * phandle2: node2 { 1529 * #list-cells = <1>; 1530 * } 1531 * 1532 * node3 { 1533 * list = <&phandle1 1 2 &phandle2 3>; 1534 * } 1535 * 1536 * To get a device_node of the `node2' node you may call this: 1537 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args); 1538 */ 1539int of_parse_phandle_with_args(const struct device_node *np, const char *list_name, 1540 const char *cells_name, int index, 1541 struct of_phandle_args *out_args) 1542{ 1543 if (index < 0) 1544 return -EINVAL; 1545 return __of_parse_phandle_with_args(np, list_name, cells_name, 0, 1546 index, out_args); 1547} 1548EXPORT_SYMBOL(of_parse_phandle_with_args); 1549 1550/** 1551 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list 1552 * @np: pointer to a device tree node containing a list 1553 * @list_name: property name that contains a list 1554 * @cell_count: number of argument cells following the phandle 1555 * @index: index of a phandle to parse out 1556 * @out_args: optional pointer to output arguments structure (will be filled) 1557 * 1558 * This function is useful to parse lists of phandles and their arguments. 1559 * Returns 0 on success and fills out_args, on error returns appropriate 1560 * errno value. 1561 * 1562 * Caller is responsible to call of_node_put() on the returned out_args->node 1563 * pointer. 1564 * 1565 * Example: 1566 * 1567 * phandle1: node1 { 1568 * } 1569 * 1570 * phandle2: node2 { 1571 * } 1572 * 1573 * node3 { 1574 * list = <&phandle1 0 2 &phandle2 2 3>; 1575 * } 1576 * 1577 * To get a device_node of the `node2' node you may call this: 1578 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args); 1579 */ 1580int of_parse_phandle_with_fixed_args(const struct device_node *np, 1581 const char *list_name, int cell_count, 1582 int index, struct of_phandle_args *out_args) 1583{ 1584 if (index < 0) 1585 return -EINVAL; 1586 return __of_parse_phandle_with_args(np, list_name, NULL, cell_count, 1587 index, out_args); 1588} 1589EXPORT_SYMBOL(of_parse_phandle_with_fixed_args); 1590 1591/** 1592 * of_count_phandle_with_args() - Find the number of phandles references in a property 1593 * @np: pointer to a device tree node containing a list 1594 * @list_name: property name that contains a list 1595 * @cells_name: property name that specifies phandles' arguments count 1596 * 1597 * Returns the number of phandle + argument tuples within a property. It 1598 * is a typical pattern to encode a list of phandle and variable 1599 * arguments into a single property. The number of arguments is encoded 1600 * by a property in the phandle-target node. For example, a gpios 1601 * property would contain a list of GPIO specifies consisting of a 1602 * phandle and 1 or more arguments. The number of arguments are 1603 * determined by the #gpio-cells property in the node pointed to by the 1604 * phandle. 1605 */ 1606int of_count_phandle_with_args(const struct device_node *np, const char *list_name, 1607 const char *cells_name) 1608{ 1609 return __of_parse_phandle_with_args(np, list_name, cells_name, 0, -1, 1610 NULL); 1611} 1612EXPORT_SYMBOL(of_count_phandle_with_args); 1613 1614/** 1615 * __of_add_property - Add a property to a node without lock operations 1616 */ 1617int __of_add_property(struct device_node *np, struct property *prop) 1618{ 1619 struct property **next; 1620 1621 prop->next = NULL; 1622 next = &np->properties; 1623 while (*next) { 1624 if (strcmp(prop->name, (*next)->name) == 0) 1625 /* duplicate ! don't insert it */ 1626 return -EEXIST; 1627 1628 next = &(*next)->next; 1629 } 1630 *next = prop; 1631 1632 return 0; 1633} 1634 1635/** 1636 * of_add_property - Add a property to a node 1637 */ 1638int of_add_property(struct device_node *np, struct property *prop) 1639{ 1640 unsigned long flags; 1641 int rc; 1642 1643 mutex_lock(&of_mutex); 1644 1645 raw_spin_lock_irqsave(&devtree_lock, flags); 1646 rc = __of_add_property(np, prop); 1647 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1648 1649 if (!rc) 1650 __of_add_property_sysfs(np, prop); 1651 1652 mutex_unlock(&of_mutex); 1653 1654 if (!rc) 1655 of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL); 1656 1657 return rc; 1658} 1659 1660int __of_remove_property(struct device_node *np, struct property *prop) 1661{ 1662 struct property **next; 1663 1664 for (next = &np->properties; *next; next = &(*next)->next) { 1665 if (*next == prop) 1666 break; 1667 } 1668 if (*next == NULL) 1669 return -ENODEV; 1670 1671 /* found the node */ 1672 *next = prop->next; 1673 prop->next = np->deadprops; 1674 np->deadprops = prop; 1675 1676 return 0; 1677} 1678 1679void __of_remove_property_sysfs(struct device_node *np, struct property *prop) 1680{ 1681 if (!IS_ENABLED(CONFIG_SYSFS)) 1682 return; 1683 1684 /* at early boot, bail here and defer setup to of_init() */ 1685 if (of_kset && of_node_is_attached(np)) 1686 sysfs_remove_bin_file(&np->kobj, &prop->attr); 1687} 1688 1689/** 1690 * of_remove_property - Remove a property from a node. 1691 * 1692 * Note that we don't actually remove it, since we have given out 1693 * who-knows-how-many pointers to the data using get-property. 1694 * Instead we just move the property to the "dead properties" 1695 * list, so it won't be found any more. 1696 */ 1697int of_remove_property(struct device_node *np, struct property *prop) 1698{ 1699 unsigned long flags; 1700 int rc; 1701 1702 mutex_lock(&of_mutex); 1703 1704 raw_spin_lock_irqsave(&devtree_lock, flags); 1705 rc = __of_remove_property(np, prop); 1706 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1707 1708 if (!rc) 1709 __of_remove_property_sysfs(np, prop); 1710 1711 mutex_unlock(&of_mutex); 1712 1713 if (!rc) 1714 of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL); 1715 1716 return rc; 1717} 1718 1719int __of_update_property(struct device_node *np, struct property *newprop, 1720 struct property **oldpropp) 1721{ 1722 struct property **next, *oldprop; 1723 1724 for (next = &np->properties; *next; next = &(*next)->next) { 1725 if (of_prop_cmp((*next)->name, newprop->name) == 0) 1726 break; 1727 } 1728 *oldpropp = oldprop = *next; 1729 1730 if (oldprop) { 1731 /* replace the node */ 1732 newprop->next = oldprop->next; 1733 *next = newprop; 1734 oldprop->next = np->deadprops; 1735 np->deadprops = oldprop; 1736 } else { 1737 /* new node */ 1738 newprop->next = NULL; 1739 *next = newprop; 1740 } 1741 1742 return 0; 1743} 1744 1745void __of_update_property_sysfs(struct device_node *np, struct property *newprop, 1746 struct property *oldprop) 1747{ 1748 if (!IS_ENABLED(CONFIG_SYSFS)) 1749 return; 1750 1751 /* At early boot, bail out and defer setup to of_init() */ 1752 if (!of_kset) 1753 return; 1754 1755 if (oldprop) 1756 sysfs_remove_bin_file(&np->kobj, &oldprop->attr); 1757 __of_add_property_sysfs(np, newprop); 1758} 1759 1760/* 1761 * of_update_property - Update a property in a node, if the property does 1762 * not exist, add it. 1763 * 1764 * Note that we don't actually remove it, since we have given out 1765 * who-knows-how-many pointers to the data using get-property. 1766 * Instead we just move the property to the "dead properties" list, 1767 * and add the new property to the property list 1768 */ 1769int of_update_property(struct device_node *np, struct property *newprop) 1770{ 1771 struct property *oldprop; 1772 unsigned long flags; 1773 int rc; 1774 1775 if (!newprop->name) 1776 return -EINVAL; 1777 1778 mutex_lock(&of_mutex); 1779 1780 raw_spin_lock_irqsave(&devtree_lock, flags); 1781 rc = __of_update_property(np, newprop, &oldprop); 1782 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1783 1784 if (!rc) 1785 __of_update_property_sysfs(np, newprop, oldprop); 1786 1787 mutex_unlock(&of_mutex); 1788 1789 if (!rc) 1790 of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop); 1791 1792 return rc; 1793} 1794 1795static void of_alias_add(struct alias_prop *ap, struct device_node *np, 1796 int id, const char *stem, int stem_len) 1797{ 1798 ap->np = np; 1799 ap->id = id; 1800 strncpy(ap->stem, stem, stem_len); 1801 ap->stem[stem_len] = 0; 1802 list_add_tail(&ap->link, &aliases_lookup); 1803 pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n", 1804 ap->alias, ap->stem, ap->id, of_node_full_name(np)); 1805} 1806 1807/** 1808 * of_alias_scan - Scan all properties of 'aliases' node 1809 * 1810 * The function scans all the properties of 'aliases' node and populate 1811 * the the global lookup table with the properties. It returns the 1812 * number of alias_prop found, or error code in error case. 1813 * 1814 * @dt_alloc: An allocator that provides a virtual address to memory 1815 * for the resulting tree 1816 */ 1817void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)) 1818{ 1819 struct property *pp; 1820 1821 of_aliases = of_find_node_by_path("/aliases"); 1822 of_chosen = of_find_node_by_path("/chosen"); 1823 if (of_chosen == NULL) 1824 of_chosen = of_find_node_by_path("/chosen@0"); 1825 1826 if (of_chosen) { 1827 /* linux,stdout-path and /aliases/stdout are for legacy compatibility */ 1828 const char *name = of_get_property(of_chosen, "stdout-path", NULL); 1829 if (!name) 1830 name = of_get_property(of_chosen, "linux,stdout-path", NULL); 1831 if (IS_ENABLED(CONFIG_PPC) && !name) 1832 name = of_get_property(of_aliases, "stdout", NULL); 1833 if (name) 1834 of_stdout = of_find_node_by_path(name); 1835 } 1836 1837 if (!of_aliases) 1838 return; 1839 1840 for_each_property_of_node(of_aliases, pp) { 1841 const char *start = pp->name; 1842 const char *end = start + strlen(start); 1843 struct device_node *np; 1844 struct alias_prop *ap; 1845 int id, len; 1846 1847 /* Skip those we do not want to proceed */ 1848 if (!strcmp(pp->name, "name") || 1849 !strcmp(pp->name, "phandle") || 1850 !strcmp(pp->name, "linux,phandle")) 1851 continue; 1852 1853 np = of_find_node_by_path(pp->value); 1854 if (!np) 1855 continue; 1856 1857 /* walk the alias backwards to extract the id and work out 1858 * the 'stem' string */ 1859 while (isdigit(*(end-1)) && end > start) 1860 end--; 1861 len = end - start; 1862 1863 if (kstrtoint(end, 10, &id) < 0) 1864 continue; 1865 1866 /* Allocate an alias_prop with enough space for the stem */ 1867 ap = dt_alloc(sizeof(*ap) + len + 1, 4); 1868 if (!ap) 1869 continue; 1870 memset(ap, 0, sizeof(*ap) + len + 1); 1871 ap->alias = start; 1872 of_alias_add(ap, np, id, start, len); 1873 } 1874} 1875 1876/** 1877 * of_alias_get_id - Get alias id for the given device_node 1878 * @np: Pointer to the given device_node 1879 * @stem: Alias stem of the given device_node 1880 * 1881 * The function travels the lookup table to get the alias id for the given 1882 * device_node and alias stem. It returns the alias id if found. 1883 */ 1884int of_alias_get_id(struct device_node *np, const char *stem) 1885{ 1886 struct alias_prop *app; 1887 int id = -ENODEV; 1888 1889 mutex_lock(&of_mutex); 1890 list_for_each_entry(app, &aliases_lookup, link) { 1891 if (strcmp(app->stem, stem) != 0) 1892 continue; 1893 1894 if (np == app->np) { 1895 id = app->id; 1896 break; 1897 } 1898 } 1899 mutex_unlock(&of_mutex); 1900 1901 return id; 1902} 1903EXPORT_SYMBOL_GPL(of_alias_get_id); 1904 1905const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 1906 u32 *pu) 1907{ 1908 const void *curv = cur; 1909 1910 if (!prop) 1911 return NULL; 1912 1913 if (!cur) { 1914 curv = prop->value; 1915 goto out_val; 1916 } 1917 1918 curv += sizeof(*cur); 1919 if (curv >= prop->value + prop->length) 1920 return NULL; 1921 1922out_val: 1923 *pu = be32_to_cpup(curv); 1924 return curv; 1925} 1926EXPORT_SYMBOL_GPL(of_prop_next_u32); 1927 1928const char *of_prop_next_string(struct property *prop, const char *cur) 1929{ 1930 const void *curv = cur; 1931 1932 if (!prop) 1933 return NULL; 1934 1935 if (!cur) 1936 return prop->value; 1937 1938 curv += strlen(cur) + 1; 1939 if (curv >= prop->value + prop->length) 1940 return NULL; 1941 1942 return curv; 1943} 1944EXPORT_SYMBOL_GPL(of_prop_next_string); 1945 1946/** 1947 * of_console_check() - Test and setup console for DT setup 1948 * @dn - Pointer to device node 1949 * @name - Name to use for preferred console without index. ex. "ttyS" 1950 * @index - Index to use for preferred console. 1951 * 1952 * Check if the given device node matches the stdout-path property in the 1953 * /chosen node. If it does then register it as the preferred console and return 1954 * TRUE. Otherwise return FALSE. 1955 */ 1956bool of_console_check(struct device_node *dn, char *name, int index) 1957{ 1958 if (!dn || dn != of_stdout || console_set_on_cmdline) 1959 return false; 1960 return !add_preferred_console(name, index, NULL); 1961} 1962EXPORT_SYMBOL_GPL(of_console_check); 1963 1964/** 1965 * of_find_next_cache_node - Find a node's subsidiary cache 1966 * @np: node of type "cpu" or "cache" 1967 * 1968 * Returns a node pointer with refcount incremented, use 1969 * of_node_put() on it when done. Caller should hold a reference 1970 * to np. 1971 */ 1972struct device_node *of_find_next_cache_node(const struct device_node *np) 1973{ 1974 struct device_node *child; 1975 const phandle *handle; 1976 1977 handle = of_get_property(np, "l2-cache", NULL); 1978 if (!handle) 1979 handle = of_get_property(np, "next-level-cache", NULL); 1980 1981 if (handle) 1982 return of_find_node_by_phandle(be32_to_cpup(handle)); 1983 1984 /* OF on pmac has nodes instead of properties named "l2-cache" 1985 * beneath CPU nodes. 1986 */ 1987 if (!strcmp(np->type, "cpu")) 1988 for_each_child_of_node(np, child) 1989 if (!strcmp(child->type, "cache")) 1990 return child; 1991 1992 return NULL; 1993} 1994 1995/** 1996 * of_graph_parse_endpoint() - parse common endpoint node properties 1997 * @node: pointer to endpoint device_node 1998 * @endpoint: pointer to the OF endpoint data structure 1999 * 2000 * The caller should hold a reference to @node. 2001 */ 2002int of_graph_parse_endpoint(const struct device_node *node, 2003 struct of_endpoint *endpoint) 2004{ 2005 struct device_node *port_node = of_get_parent(node); 2006 2007 WARN_ONCE(!port_node, "%s(): endpoint %s has no parent node\n", 2008 __func__, node->full_name); 2009 2010 memset(endpoint, 0, sizeof(*endpoint)); 2011 2012 endpoint->local_node = node; 2013 /* 2014 * It doesn't matter whether the two calls below succeed. 2015 * If they don't then the default value 0 is used. 2016 */ 2017 of_property_read_u32(port_node, "reg", &endpoint->port); 2018 of_property_read_u32(node, "reg", &endpoint->id); 2019 2020 of_node_put(port_node); 2021 2022 return 0; 2023} 2024EXPORT_SYMBOL(of_graph_parse_endpoint); 2025 2026/** 2027 * of_graph_get_next_endpoint() - get next endpoint node 2028 * @parent: pointer to the parent device node 2029 * @prev: previous endpoint node, or NULL to get first 2030 * 2031 * Return: An 'endpoint' node pointer with refcount incremented. Refcount 2032 * of the passed @prev node is not decremented, the caller have to use 2033 * of_node_put() on it when done. 2034 */ 2035struct device_node *of_graph_get_next_endpoint(const struct device_node *parent, 2036 struct device_node *prev) 2037{ 2038 struct device_node *endpoint; 2039 struct device_node *port; 2040 2041 if (!parent) 2042 return NULL; 2043 2044 /* 2045 * Start by locating the port node. If no previous endpoint is specified 2046 * search for the first port node, otherwise get the previous endpoint 2047 * parent port node. 2048 */ 2049 if (!prev) { 2050 struct device_node *node; 2051 2052 node = of_get_child_by_name(parent, "ports"); 2053 if (node) 2054 parent = node; 2055 2056 port = of_get_child_by_name(parent, "port"); 2057 of_node_put(node); 2058 2059 if (!port) { 2060 pr_err("%s(): no port node found in %s\n", 2061 __func__, parent->full_name); 2062 return NULL; 2063 } 2064 } else { 2065 port = of_get_parent(prev); 2066 if (WARN_ONCE(!port, "%s(): endpoint %s has no parent node\n", 2067 __func__, prev->full_name)) 2068 return NULL; 2069 2070 /* 2071 * Avoid dropping prev node refcount to 0 when getting the next 2072 * child below. 2073 */ 2074 of_node_get(prev); 2075 } 2076 2077 while (1) { 2078 /* 2079 * Now that we have a port node, get the next endpoint by 2080 * getting the next child. If the previous endpoint is NULL this 2081 * will return the first child. 2082 */ 2083 endpoint = of_get_next_child(port, prev); 2084 if (endpoint) { 2085 of_node_put(port); 2086 return endpoint; 2087 } 2088 2089 /* No more endpoints under this port, try the next one. */ 2090 prev = NULL; 2091 2092 do { 2093 port = of_get_next_child(parent, port); 2094 if (!port) 2095 return NULL; 2096 } while (of_node_cmp(port->name, "port")); 2097 } 2098} 2099EXPORT_SYMBOL(of_graph_get_next_endpoint); 2100 2101/** 2102 * of_graph_get_remote_port_parent() - get remote port's parent node 2103 * @node: pointer to a local endpoint device_node 2104 * 2105 * Return: Remote device node associated with remote endpoint node linked 2106 * to @node. Use of_node_put() on it when done. 2107 */ 2108struct device_node *of_graph_get_remote_port_parent( 2109 const struct device_node *node) 2110{ 2111 struct device_node *np; 2112 unsigned int depth; 2113 2114 /* Get remote endpoint node. */ 2115 np = of_parse_phandle(node, "remote-endpoint", 0); 2116 2117 /* Walk 3 levels up only if there is 'ports' node. */ 2118 for (depth = 3; depth && np; depth--) { 2119 np = of_get_next_parent(np); 2120 if (depth == 2 && of_node_cmp(np->name, "ports")) 2121 break; 2122 } 2123 return np; 2124} 2125EXPORT_SYMBOL(of_graph_get_remote_port_parent); 2126 2127/** 2128 * of_graph_get_remote_port() - get remote port node 2129 * @node: pointer to a local endpoint device_node 2130 * 2131 * Return: Remote port node associated with remote endpoint node linked 2132 * to @node. Use of_node_put() on it when done. 2133 */ 2134struct device_node *of_graph_get_remote_port(const struct device_node *node) 2135{ 2136 struct device_node *np; 2137 2138 /* Get remote endpoint node. */ 2139 np = of_parse_phandle(node, "remote-endpoint", 0); 2140 if (!np) 2141 return NULL; 2142 return of_get_next_parent(np); 2143} 2144EXPORT_SYMBOL(of_graph_get_remote_port); 2145