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