1 /* 2 * Procedures for creating, accessing and interpreting the device tree. 3 * 4 * Paul Mackerras August 1996. 5 * Copyright (C) 1996-2005 Paul Mackerras. 6 * 7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 8 * {engebret|bergner}@us.ibm.com 9 * 10 * Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net 11 * 12 * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and 13 * Grant Likely. 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License 17 * as published by the Free Software Foundation; either version 18 * 2 of the License, or (at your option) any later version. 19 */ 20 #include <linux/ctype.h> 21 #include <linux/module.h> 22 #include <linux/of.h> 23 #include <linux/spinlock.h> 24 #include <linux/slab.h> 25 #include <linux/proc_fs.h> 26 27 #include "of_private.h" 28 29 LIST_HEAD(aliases_lookup); 30 31 struct device_node *of_allnodes; 32 EXPORT_SYMBOL(of_allnodes); 33 struct device_node *of_chosen; 34 struct device_node *of_aliases; 35 36 DEFINE_MUTEX(of_aliases_mutex); 37 38 /* use when traversing tree through the allnext, child, sibling, 39 * or parent members of struct device_node. 40 */ 41 DEFINE_RAW_SPINLOCK(devtree_lock); 42 43 int of_n_addr_cells(struct device_node *np) 44 { 45 const __be32 *ip; 46 47 do { 48 if (np->parent) 49 np = np->parent; 50 ip = of_get_property(np, "#address-cells", NULL); 51 if (ip) 52 return be32_to_cpup(ip); 53 } while (np->parent); 54 /* No #address-cells property for the root node */ 55 return OF_ROOT_NODE_ADDR_CELLS_DEFAULT; 56 } 57 EXPORT_SYMBOL(of_n_addr_cells); 58 59 int of_n_size_cells(struct device_node *np) 60 { 61 const __be32 *ip; 62 63 do { 64 if (np->parent) 65 np = np->parent; 66 ip = of_get_property(np, "#size-cells", NULL); 67 if (ip) 68 return be32_to_cpup(ip); 69 } while (np->parent); 70 /* No #size-cells property for the root node */ 71 return OF_ROOT_NODE_SIZE_CELLS_DEFAULT; 72 } 73 EXPORT_SYMBOL(of_n_size_cells); 74 75 #if defined(CONFIG_OF_DYNAMIC) 76 /** 77 * of_node_get - Increment refcount of a node 78 * @node: Node to inc refcount, NULL is supported to 79 * simplify writing of callers 80 * 81 * Returns node. 82 */ 83 struct device_node *of_node_get(struct device_node *node) 84 { 85 if (node) 86 kref_get(&node->kref); 87 return node; 88 } 89 EXPORT_SYMBOL(of_node_get); 90 91 static inline struct device_node *kref_to_device_node(struct kref *kref) 92 { 93 return container_of(kref, struct device_node, kref); 94 } 95 96 /** 97 * of_node_release - release a dynamically allocated node 98 * @kref: kref element of the node to be released 99 * 100 * In of_node_put() this function is passed to kref_put() 101 * as the destructor. 102 */ 103 static void of_node_release(struct kref *kref) 104 { 105 struct device_node *node = kref_to_device_node(kref); 106 struct property *prop = node->properties; 107 108 /* We should never be releasing nodes that haven't been detached. */ 109 if (!of_node_check_flag(node, OF_DETACHED)) { 110 pr_err("ERROR: Bad of_node_put() on %s\n", node->full_name); 111 dump_stack(); 112 kref_init(&node->kref); 113 return; 114 } 115 116 if (!of_node_check_flag(node, OF_DYNAMIC)) 117 return; 118 119 while (prop) { 120 struct property *next = prop->next; 121 kfree(prop->name); 122 kfree(prop->value); 123 kfree(prop); 124 prop = next; 125 126 if (!prop) { 127 prop = node->deadprops; 128 node->deadprops = NULL; 129 } 130 } 131 kfree(node->full_name); 132 kfree(node->data); 133 kfree(node); 134 } 135 136 /** 137 * of_node_put - Decrement refcount of a node 138 * @node: Node to dec refcount, NULL is supported to 139 * simplify writing of callers 140 * 141 */ 142 void of_node_put(struct device_node *node) 143 { 144 if (node) 145 kref_put(&node->kref, of_node_release); 146 } 147 EXPORT_SYMBOL(of_node_put); 148 #endif /* CONFIG_OF_DYNAMIC */ 149 150 static struct property *__of_find_property(const struct device_node *np, 151 const char *name, int *lenp) 152 { 153 struct property *pp; 154 155 if (!np) 156 return NULL; 157 158 for (pp = np->properties; pp; pp = pp->next) { 159 if (of_prop_cmp(pp->name, name) == 0) { 160 if (lenp) 161 *lenp = pp->length; 162 break; 163 } 164 } 165 166 return pp; 167 } 168 169 struct property *of_find_property(const struct device_node *np, 170 const char *name, 171 int *lenp) 172 { 173 struct property *pp; 174 unsigned long flags; 175 176 raw_spin_lock_irqsave(&devtree_lock, flags); 177 pp = __of_find_property(np, name, lenp); 178 raw_spin_unlock_irqrestore(&devtree_lock, flags); 179 180 return pp; 181 } 182 EXPORT_SYMBOL(of_find_property); 183 184 /** 185 * of_find_all_nodes - Get next node in global list 186 * @prev: Previous node or NULL to start iteration 187 * of_node_put() will be called on it 188 * 189 * Returns a node pointer with refcount incremented, use 190 * of_node_put() on it when done. 191 */ 192 struct device_node *of_find_all_nodes(struct device_node *prev) 193 { 194 struct device_node *np; 195 196 raw_spin_lock(&devtree_lock); 197 np = prev ? prev->allnext : of_allnodes; 198 for (; np != NULL; np = np->allnext) 199 if (of_node_get(np)) 200 break; 201 of_node_put(prev); 202 raw_spin_unlock(&devtree_lock); 203 return np; 204 } 205 EXPORT_SYMBOL(of_find_all_nodes); 206 207 /* 208 * Find a property with a given name for a given node 209 * and return the value. 210 */ 211 static const void *__of_get_property(const struct device_node *np, 212 const char *name, int *lenp) 213 { 214 struct property *pp = __of_find_property(np, name, lenp); 215 216 return pp ? pp->value : NULL; 217 } 218 219 /* 220 * Find a property with a given name for a given node 221 * and return the value. 222 */ 223 const void *of_get_property(const struct device_node *np, const char *name, 224 int *lenp) 225 { 226 struct property *pp = of_find_property(np, name, lenp); 227 228 return pp ? pp->value : NULL; 229 } 230 EXPORT_SYMBOL(of_get_property); 231 232 /** Checks if the given "compat" string matches one of the strings in 233 * the device's "compatible" property 234 */ 235 static int __of_device_is_compatible(const struct device_node *device, 236 const char *compat) 237 { 238 const char* cp; 239 int cplen, l; 240 241 cp = __of_get_property(device, "compatible", &cplen); 242 if (cp == NULL) 243 return 0; 244 while (cplen > 0) { 245 if (of_compat_cmp(cp, compat, strlen(compat)) == 0) 246 return 1; 247 l = strlen(cp) + 1; 248 cp += l; 249 cplen -= l; 250 } 251 252 return 0; 253 } 254 255 /** Checks if the given "compat" string matches one of the strings in 256 * the device's "compatible" property 257 */ 258 int of_device_is_compatible(const struct device_node *device, 259 const char *compat) 260 { 261 unsigned long flags; 262 int res; 263 264 raw_spin_lock_irqsave(&devtree_lock, flags); 265 res = __of_device_is_compatible(device, compat); 266 raw_spin_unlock_irqrestore(&devtree_lock, flags); 267 return res; 268 } 269 EXPORT_SYMBOL(of_device_is_compatible); 270 271 /** 272 * of_machine_is_compatible - Test root of device tree for a given compatible value 273 * @compat: compatible string to look for in root node's compatible property. 274 * 275 * Returns true if the root node has the given value in its 276 * compatible property. 277 */ 278 int of_machine_is_compatible(const char *compat) 279 { 280 struct device_node *root; 281 int rc = 0; 282 283 root = of_find_node_by_path("/"); 284 if (root) { 285 rc = of_device_is_compatible(root, compat); 286 of_node_put(root); 287 } 288 return rc; 289 } 290 EXPORT_SYMBOL(of_machine_is_compatible); 291 292 /** 293 * __of_device_is_available - check if a device is available for use 294 * 295 * @device: Node to check for availability, with locks already held 296 * 297 * Returns 1 if the status property is absent or set to "okay" or "ok", 298 * 0 otherwise 299 */ 300 static int __of_device_is_available(const struct device_node *device) 301 { 302 const char *status; 303 int statlen; 304 305 status = __of_get_property(device, "status", &statlen); 306 if (status == NULL) 307 return 1; 308 309 if (statlen > 0) { 310 if (!strcmp(status, "okay") || !strcmp(status, "ok")) 311 return 1; 312 } 313 314 return 0; 315 } 316 317 /** 318 * of_device_is_available - check if a device is available for use 319 * 320 * @device: Node to check for availability 321 * 322 * Returns 1 if the status property is absent or set to "okay" or "ok", 323 * 0 otherwise 324 */ 325 int of_device_is_available(const struct device_node *device) 326 { 327 unsigned long flags; 328 int res; 329 330 raw_spin_lock_irqsave(&devtree_lock, flags); 331 res = __of_device_is_available(device); 332 raw_spin_unlock_irqrestore(&devtree_lock, flags); 333 return res; 334 335 } 336 EXPORT_SYMBOL(of_device_is_available); 337 338 /** 339 * of_get_parent - Get a node's parent if any 340 * @node: Node to get parent 341 * 342 * Returns a node pointer with refcount incremented, use 343 * of_node_put() on it when done. 344 */ 345 struct device_node *of_get_parent(const struct device_node *node) 346 { 347 struct device_node *np; 348 unsigned long flags; 349 350 if (!node) 351 return NULL; 352 353 raw_spin_lock_irqsave(&devtree_lock, flags); 354 np = of_node_get(node->parent); 355 raw_spin_unlock_irqrestore(&devtree_lock, flags); 356 return np; 357 } 358 EXPORT_SYMBOL(of_get_parent); 359 360 /** 361 * of_get_next_parent - Iterate to a node's parent 362 * @node: Node to get parent of 363 * 364 * This is like of_get_parent() except that it drops the 365 * refcount on the passed node, making it suitable for iterating 366 * through a node's parents. 367 * 368 * Returns a node pointer with refcount incremented, use 369 * of_node_put() on it when done. 370 */ 371 struct device_node *of_get_next_parent(struct device_node *node) 372 { 373 struct device_node *parent; 374 unsigned long flags; 375 376 if (!node) 377 return NULL; 378 379 raw_spin_lock_irqsave(&devtree_lock, flags); 380 parent = of_node_get(node->parent); 381 of_node_put(node); 382 raw_spin_unlock_irqrestore(&devtree_lock, flags); 383 return parent; 384 } 385 386 /** 387 * of_get_next_child - Iterate a node childs 388 * @node: parent node 389 * @prev: previous child of the parent node, or NULL to get first 390 * 391 * Returns a node pointer with refcount incremented, use 392 * of_node_put() on it when done. 393 */ 394 struct device_node *of_get_next_child(const struct device_node *node, 395 struct device_node *prev) 396 { 397 struct device_node *next; 398 unsigned long flags; 399 400 raw_spin_lock_irqsave(&devtree_lock, flags); 401 next = prev ? prev->sibling : node->child; 402 for (; next; next = next->sibling) 403 if (of_node_get(next)) 404 break; 405 of_node_put(prev); 406 raw_spin_unlock_irqrestore(&devtree_lock, flags); 407 return next; 408 } 409 EXPORT_SYMBOL(of_get_next_child); 410 411 /** 412 * of_get_next_available_child - Find the next available child node 413 * @node: parent node 414 * @prev: previous child of the parent node, or NULL to get first 415 * 416 * This function is like of_get_next_child(), except that it 417 * automatically skips any disabled nodes (i.e. status = "disabled"). 418 */ 419 struct device_node *of_get_next_available_child(const struct device_node *node, 420 struct device_node *prev) 421 { 422 struct device_node *next; 423 424 raw_spin_lock(&devtree_lock); 425 next = prev ? prev->sibling : node->child; 426 for (; next; next = next->sibling) { 427 if (!__of_device_is_available(next)) 428 continue; 429 if (of_node_get(next)) 430 break; 431 } 432 of_node_put(prev); 433 raw_spin_unlock(&devtree_lock); 434 return next; 435 } 436 EXPORT_SYMBOL(of_get_next_available_child); 437 438 /** 439 * of_get_child_by_name - Find the child node by name for a given parent 440 * @node: parent node 441 * @name: child name to look for. 442 * 443 * This function looks for child node for given matching name 444 * 445 * Returns a node pointer if found, with refcount incremented, use 446 * of_node_put() on it when done. 447 * Returns NULL if node is not found. 448 */ 449 struct device_node *of_get_child_by_name(const struct device_node *node, 450 const char *name) 451 { 452 struct device_node *child; 453 454 for_each_child_of_node(node, child) 455 if (child->name && (of_node_cmp(child->name, name) == 0)) 456 break; 457 return child; 458 } 459 EXPORT_SYMBOL(of_get_child_by_name); 460 461 /** 462 * of_find_node_by_path - Find a node matching a full OF path 463 * @path: The full path to match 464 * 465 * Returns a node pointer with refcount incremented, use 466 * of_node_put() on it when done. 467 */ 468 struct device_node *of_find_node_by_path(const char *path) 469 { 470 struct device_node *np = of_allnodes; 471 unsigned long flags; 472 473 raw_spin_lock_irqsave(&devtree_lock, flags); 474 for (; np; np = np->allnext) { 475 if (np->full_name && (of_node_cmp(np->full_name, path) == 0) 476 && of_node_get(np)) 477 break; 478 } 479 raw_spin_unlock_irqrestore(&devtree_lock, flags); 480 return np; 481 } 482 EXPORT_SYMBOL(of_find_node_by_path); 483 484 /** 485 * of_find_node_by_name - Find a node by its "name" property 486 * @from: The node to start searching from or NULL, the node 487 * you pass will not be searched, only the next one 488 * will; typically, you pass what the previous call 489 * returned. of_node_put() will be called on it 490 * @name: The name string to match against 491 * 492 * Returns a node pointer with refcount incremented, use 493 * of_node_put() on it when done. 494 */ 495 struct device_node *of_find_node_by_name(struct device_node *from, 496 const char *name) 497 { 498 struct device_node *np; 499 unsigned long flags; 500 501 raw_spin_lock_irqsave(&devtree_lock, flags); 502 np = from ? from->allnext : of_allnodes; 503 for (; np; np = np->allnext) 504 if (np->name && (of_node_cmp(np->name, name) == 0) 505 && of_node_get(np)) 506 break; 507 of_node_put(from); 508 raw_spin_unlock_irqrestore(&devtree_lock, flags); 509 return np; 510 } 511 EXPORT_SYMBOL(of_find_node_by_name); 512 513 /** 514 * of_find_node_by_type - Find a node by its "device_type" property 515 * @from: The node to start searching from, or NULL to start searching 516 * the entire device tree. The node you pass will not be 517 * searched, only the next one will; typically, you pass 518 * what the previous call returned. of_node_put() will be 519 * called on from for you. 520 * @type: The type string to match against 521 * 522 * Returns a node pointer with refcount incremented, use 523 * of_node_put() on it when done. 524 */ 525 struct device_node *of_find_node_by_type(struct device_node *from, 526 const char *type) 527 { 528 struct device_node *np; 529 unsigned long flags; 530 531 raw_spin_lock_irqsave(&devtree_lock, flags); 532 np = from ? from->allnext : of_allnodes; 533 for (; np; np = np->allnext) 534 if (np->type && (of_node_cmp(np->type, type) == 0) 535 && of_node_get(np)) 536 break; 537 of_node_put(from); 538 raw_spin_unlock_irqrestore(&devtree_lock, flags); 539 return np; 540 } 541 EXPORT_SYMBOL(of_find_node_by_type); 542 543 /** 544 * of_find_compatible_node - Find a node based on type and one of the 545 * tokens in its "compatible" property 546 * @from: The node to start searching from or NULL, the node 547 * you pass will not be searched, only the next one 548 * will; typically, you pass what the previous call 549 * returned. of_node_put() will be called on it 550 * @type: The type string to match "device_type" or NULL to ignore 551 * @compatible: The string to match to one of the tokens in the device 552 * "compatible" list. 553 * 554 * Returns a node pointer with refcount incremented, use 555 * of_node_put() on it when done. 556 */ 557 struct device_node *of_find_compatible_node(struct device_node *from, 558 const char *type, const char *compatible) 559 { 560 struct device_node *np; 561 unsigned long flags; 562 563 raw_spin_lock_irqsave(&devtree_lock, flags); 564 np = from ? from->allnext : of_allnodes; 565 for (; np; np = np->allnext) { 566 if (type 567 && !(np->type && (of_node_cmp(np->type, type) == 0))) 568 continue; 569 if (__of_device_is_compatible(np, compatible) && 570 of_node_get(np)) 571 break; 572 } 573 of_node_put(from); 574 raw_spin_unlock_irqrestore(&devtree_lock, flags); 575 return np; 576 } 577 EXPORT_SYMBOL(of_find_compatible_node); 578 579 /** 580 * of_find_node_with_property - Find a node which has a property with 581 * the given name. 582 * @from: The node to start searching from or NULL, the node 583 * you pass will not be searched, only the next one 584 * will; typically, you pass what the previous call 585 * returned. of_node_put() will be called on it 586 * @prop_name: The name of the property to look for. 587 * 588 * Returns a node pointer with refcount incremented, use 589 * of_node_put() on it when done. 590 */ 591 struct device_node *of_find_node_with_property(struct device_node *from, 592 const char *prop_name) 593 { 594 struct device_node *np; 595 struct property *pp; 596 unsigned long flags; 597 598 raw_spin_lock_irqsave(&devtree_lock, flags); 599 np = from ? from->allnext : of_allnodes; 600 for (; np; np = np->allnext) { 601 for (pp = np->properties; pp; pp = pp->next) { 602 if (of_prop_cmp(pp->name, prop_name) == 0) { 603 of_node_get(np); 604 goto out; 605 } 606 } 607 } 608 out: 609 of_node_put(from); 610 raw_spin_unlock_irqrestore(&devtree_lock, flags); 611 return np; 612 } 613 EXPORT_SYMBOL(of_find_node_with_property); 614 615 static 616 const struct of_device_id *__of_match_node(const struct of_device_id *matches, 617 const struct device_node *node) 618 { 619 if (!matches) 620 return NULL; 621 622 while (matches->name[0] || matches->type[0] || matches->compatible[0]) { 623 int match = 1; 624 if (matches->name[0]) 625 match &= node->name 626 && !strcmp(matches->name, node->name); 627 if (matches->type[0]) 628 match &= node->type 629 && !strcmp(matches->type, node->type); 630 if (matches->compatible[0]) 631 match &= __of_device_is_compatible(node, 632 matches->compatible); 633 if (match) 634 return matches; 635 matches++; 636 } 637 return NULL; 638 } 639 640 /** 641 * of_match_node - Tell if an device_node has a matching of_match structure 642 * @matches: array of of device match structures to search in 643 * @node: the of device structure to match against 644 * 645 * Low level utility function used by device matching. 646 */ 647 const struct of_device_id *of_match_node(const struct of_device_id *matches, 648 const struct device_node *node) 649 { 650 const struct of_device_id *match; 651 unsigned long flags; 652 653 raw_spin_lock_irqsave(&devtree_lock, flags); 654 match = __of_match_node(matches, node); 655 raw_spin_unlock_irqrestore(&devtree_lock, flags); 656 return match; 657 } 658 EXPORT_SYMBOL(of_match_node); 659 660 /** 661 * of_find_matching_node_and_match - Find a node based on an of_device_id 662 * match table. 663 * @from: The node to start searching from or NULL, the node 664 * you pass will not be searched, only the next one 665 * will; typically, you pass what the previous call 666 * returned. of_node_put() will be called on it 667 * @matches: array of of device match structures to search in 668 * @match Updated to point at the matches entry which matched 669 * 670 * Returns a node pointer with refcount incremented, use 671 * of_node_put() on it when done. 672 */ 673 struct device_node *of_find_matching_node_and_match(struct device_node *from, 674 const struct of_device_id *matches, 675 const struct of_device_id **match) 676 { 677 struct device_node *np; 678 const struct of_device_id *m; 679 unsigned long flags; 680 681 if (match) 682 *match = NULL; 683 684 raw_spin_lock_irqsave(&devtree_lock, flags); 685 np = from ? from->allnext : of_allnodes; 686 for (; np; np = np->allnext) { 687 m = __of_match_node(matches, np); 688 if (m && of_node_get(np)) { 689 if (match) 690 *match = m; 691 break; 692 } 693 } 694 of_node_put(from); 695 raw_spin_unlock_irqrestore(&devtree_lock, flags); 696 return np; 697 } 698 EXPORT_SYMBOL(of_find_matching_node_and_match); 699 700 /** 701 * of_modalias_node - Lookup appropriate modalias for a device node 702 * @node: pointer to a device tree node 703 * @modalias: Pointer to buffer that modalias value will be copied into 704 * @len: Length of modalias value 705 * 706 * Based on the value of the compatible property, this routine will attempt 707 * to choose an appropriate modalias value for a particular device tree node. 708 * It does this by stripping the manufacturer prefix (as delimited by a ',') 709 * from the first entry in the compatible list property. 710 * 711 * This routine returns 0 on success, <0 on failure. 712 */ 713 int of_modalias_node(struct device_node *node, char *modalias, int len) 714 { 715 const char *compatible, *p; 716 int cplen; 717 718 compatible = of_get_property(node, "compatible", &cplen); 719 if (!compatible || strlen(compatible) > cplen) 720 return -ENODEV; 721 p = strchr(compatible, ','); 722 strlcpy(modalias, p ? p + 1 : compatible, len); 723 return 0; 724 } 725 EXPORT_SYMBOL_GPL(of_modalias_node); 726 727 /** 728 * of_find_node_by_phandle - Find a node given a phandle 729 * @handle: phandle of the node to find 730 * 731 * Returns a node pointer with refcount incremented, use 732 * of_node_put() on it when done. 733 */ 734 struct device_node *of_find_node_by_phandle(phandle handle) 735 { 736 struct device_node *np; 737 738 raw_spin_lock(&devtree_lock); 739 for (np = of_allnodes; np; np = np->allnext) 740 if (np->phandle == handle) 741 break; 742 of_node_get(np); 743 raw_spin_unlock(&devtree_lock); 744 return np; 745 } 746 EXPORT_SYMBOL(of_find_node_by_phandle); 747 748 /** 749 * of_property_read_u8_array - Find and read an array of u8 from a property. 750 * 751 * @np: device node from which the property value is to be read. 752 * @propname: name of the property to be searched. 753 * @out_value: pointer to return value, modified only if return value is 0. 754 * @sz: number of array elements to read 755 * 756 * Search for a property in a device node and read 8-bit value(s) from 757 * it. Returns 0 on success, -EINVAL if the property does not exist, 758 * -ENODATA if property does not have a value, and -EOVERFLOW if the 759 * property data isn't large enough. 760 * 761 * dts entry of array should be like: 762 * property = /bits/ 8 <0x50 0x60 0x70>; 763 * 764 * The out_value is modified only if a valid u8 value can be decoded. 765 */ 766 int of_property_read_u8_array(const struct device_node *np, 767 const char *propname, u8 *out_values, size_t sz) 768 { 769 struct property *prop = of_find_property(np, propname, NULL); 770 const u8 *val; 771 772 if (!prop) 773 return -EINVAL; 774 if (!prop->value) 775 return -ENODATA; 776 if ((sz * sizeof(*out_values)) > prop->length) 777 return -EOVERFLOW; 778 779 val = prop->value; 780 while (sz--) 781 *out_values++ = *val++; 782 return 0; 783 } 784 EXPORT_SYMBOL_GPL(of_property_read_u8_array); 785 786 /** 787 * of_property_read_u16_array - Find and read an array of u16 from a property. 788 * 789 * @np: device node from which the property value is to be read. 790 * @propname: name of the property to be searched. 791 * @out_value: pointer to return value, modified only if return value is 0. 792 * @sz: number of array elements to read 793 * 794 * Search for a property in a device node and read 16-bit value(s) from 795 * it. Returns 0 on success, -EINVAL if the property does not exist, 796 * -ENODATA if property does not have a value, and -EOVERFLOW if the 797 * property data isn't large enough. 798 * 799 * dts entry of array should be like: 800 * property = /bits/ 16 <0x5000 0x6000 0x7000>; 801 * 802 * The out_value is modified only if a valid u16 value can be decoded. 803 */ 804 int of_property_read_u16_array(const struct device_node *np, 805 const char *propname, u16 *out_values, size_t sz) 806 { 807 struct property *prop = of_find_property(np, propname, NULL); 808 const __be16 *val; 809 810 if (!prop) 811 return -EINVAL; 812 if (!prop->value) 813 return -ENODATA; 814 if ((sz * sizeof(*out_values)) > prop->length) 815 return -EOVERFLOW; 816 817 val = prop->value; 818 while (sz--) 819 *out_values++ = be16_to_cpup(val++); 820 return 0; 821 } 822 EXPORT_SYMBOL_GPL(of_property_read_u16_array); 823 824 /** 825 * of_property_read_u32_array - Find and read an array of 32 bit integers 826 * from a property. 827 * 828 * @np: device node from which the property value is to be read. 829 * @propname: name of the property to be searched. 830 * @out_value: pointer to return value, modified only if return value is 0. 831 * @sz: number of array elements to read 832 * 833 * Search for a property in a device node and read 32-bit value(s) from 834 * it. Returns 0 on success, -EINVAL if the property does not exist, 835 * -ENODATA if property does not have a value, and -EOVERFLOW if the 836 * property data isn't large enough. 837 * 838 * The out_value is modified only if a valid u32 value can be decoded. 839 */ 840 int of_property_read_u32_array(const struct device_node *np, 841 const char *propname, u32 *out_values, 842 size_t sz) 843 { 844 struct property *prop = of_find_property(np, propname, NULL); 845 const __be32 *val; 846 847 if (!prop) 848 return -EINVAL; 849 if (!prop->value) 850 return -ENODATA; 851 if ((sz * sizeof(*out_values)) > prop->length) 852 return -EOVERFLOW; 853 854 val = prop->value; 855 while (sz--) 856 *out_values++ = be32_to_cpup(val++); 857 return 0; 858 } 859 EXPORT_SYMBOL_GPL(of_property_read_u32_array); 860 861 /** 862 * of_property_read_u64 - Find and read a 64 bit integer from a property 863 * @np: device node from which the property value is to be read. 864 * @propname: name of the property to be searched. 865 * @out_value: pointer to return value, modified only if return value is 0. 866 * 867 * Search for a property in a device node and read a 64-bit value from 868 * it. Returns 0 on success, -EINVAL if the property does not exist, 869 * -ENODATA if property does not have a value, and -EOVERFLOW if the 870 * property data isn't large enough. 871 * 872 * The out_value is modified only if a valid u64 value can be decoded. 873 */ 874 int of_property_read_u64(const struct device_node *np, const char *propname, 875 u64 *out_value) 876 { 877 struct property *prop = of_find_property(np, propname, NULL); 878 879 if (!prop) 880 return -EINVAL; 881 if (!prop->value) 882 return -ENODATA; 883 if (sizeof(*out_value) > prop->length) 884 return -EOVERFLOW; 885 *out_value = of_read_number(prop->value, 2); 886 return 0; 887 } 888 EXPORT_SYMBOL_GPL(of_property_read_u64); 889 890 /** 891 * of_property_read_string - Find and read a string from a property 892 * @np: device node from which the property value is to be read. 893 * @propname: name of the property to be searched. 894 * @out_string: pointer to null terminated return string, modified only if 895 * return value is 0. 896 * 897 * Search for a property in a device tree node and retrieve a null 898 * terminated string value (pointer to data, not a copy). Returns 0 on 899 * success, -EINVAL if the property does not exist, -ENODATA if property 900 * does not have a value, and -EILSEQ if the string is not null-terminated 901 * within the length of the property data. 902 * 903 * The out_string pointer is modified only if a valid string can be decoded. 904 */ 905 int of_property_read_string(struct device_node *np, const char *propname, 906 const char **out_string) 907 { 908 struct property *prop = of_find_property(np, propname, NULL); 909 if (!prop) 910 return -EINVAL; 911 if (!prop->value) 912 return -ENODATA; 913 if (strnlen(prop->value, prop->length) >= prop->length) 914 return -EILSEQ; 915 *out_string = prop->value; 916 return 0; 917 } 918 EXPORT_SYMBOL_GPL(of_property_read_string); 919 920 /** 921 * of_property_read_string_index - Find and read a string from a multiple 922 * strings property. 923 * @np: device node from which the property value is to be read. 924 * @propname: name of the property to be searched. 925 * @index: index of the string in the list of strings 926 * @out_string: pointer to null terminated return string, modified only if 927 * return value is 0. 928 * 929 * Search for a property in a device tree node and retrieve a null 930 * terminated string value (pointer to data, not a copy) in the list of strings 931 * contained in that property. 932 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if 933 * property does not have a value, and -EILSEQ if the string is not 934 * null-terminated within the length of the property data. 935 * 936 * The out_string pointer is modified only if a valid string can be decoded. 937 */ 938 int of_property_read_string_index(struct device_node *np, const char *propname, 939 int index, const char **output) 940 { 941 struct property *prop = of_find_property(np, propname, NULL); 942 int i = 0; 943 size_t l = 0, total = 0; 944 const char *p; 945 946 if (!prop) 947 return -EINVAL; 948 if (!prop->value) 949 return -ENODATA; 950 if (strnlen(prop->value, prop->length) >= prop->length) 951 return -EILSEQ; 952 953 p = prop->value; 954 955 for (i = 0; total < prop->length; total += l, p += l) { 956 l = strlen(p) + 1; 957 if (i++ == index) { 958 *output = p; 959 return 0; 960 } 961 } 962 return -ENODATA; 963 } 964 EXPORT_SYMBOL_GPL(of_property_read_string_index); 965 966 /** 967 * of_property_match_string() - Find string in a list and return index 968 * @np: pointer to node containing string list property 969 * @propname: string list property name 970 * @string: pointer to string to search for in string list 971 * 972 * This function searches a string list property and returns the index 973 * of a specific string value. 974 */ 975 int of_property_match_string(struct device_node *np, const char *propname, 976 const char *string) 977 { 978 struct property *prop = of_find_property(np, propname, NULL); 979 size_t l; 980 int i; 981 const char *p, *end; 982 983 if (!prop) 984 return -EINVAL; 985 if (!prop->value) 986 return -ENODATA; 987 988 p = prop->value; 989 end = p + prop->length; 990 991 for (i = 0; p < end; i++, p += l) { 992 l = strlen(p) + 1; 993 if (p + l > end) 994 return -EILSEQ; 995 pr_debug("comparing %s with %s\n", string, p); 996 if (strcmp(string, p) == 0) 997 return i; /* Found it; return index */ 998 } 999 return -ENODATA; 1000 } 1001 EXPORT_SYMBOL_GPL(of_property_match_string); 1002 1003 /** 1004 * of_property_count_strings - Find and return the number of strings from a 1005 * multiple strings property. 1006 * @np: device node from which the property value is to be read. 1007 * @propname: name of the property to be searched. 1008 * 1009 * Search for a property in a device tree node and retrieve the number of null 1010 * terminated string contain in it. Returns the number of strings on 1011 * success, -EINVAL if the property does not exist, -ENODATA if property 1012 * does not have a value, and -EILSEQ if the string is not null-terminated 1013 * within the length of the property data. 1014 */ 1015 int of_property_count_strings(struct device_node *np, const char *propname) 1016 { 1017 struct property *prop = of_find_property(np, propname, NULL); 1018 int i = 0; 1019 size_t l = 0, total = 0; 1020 const char *p; 1021 1022 if (!prop) 1023 return -EINVAL; 1024 if (!prop->value) 1025 return -ENODATA; 1026 if (strnlen(prop->value, prop->length) >= prop->length) 1027 return -EILSEQ; 1028 1029 p = prop->value; 1030 1031 for (i = 0; total < prop->length; total += l, p += l, i++) 1032 l = strlen(p) + 1; 1033 1034 return i; 1035 } 1036 EXPORT_SYMBOL_GPL(of_property_count_strings); 1037 1038 /** 1039 * of_parse_phandle - Resolve a phandle property to a device_node pointer 1040 * @np: Pointer to device node holding phandle property 1041 * @phandle_name: Name of property holding a phandle value 1042 * @index: For properties holding a table of phandles, this is the index into 1043 * the table 1044 * 1045 * Returns the device_node pointer with refcount incremented. Use 1046 * of_node_put() on it when done. 1047 */ 1048 struct device_node *of_parse_phandle(const struct device_node *np, 1049 const char *phandle_name, int index) 1050 { 1051 const __be32 *phandle; 1052 int size; 1053 1054 phandle = of_get_property(np, phandle_name, &size); 1055 if ((!phandle) || (size < sizeof(*phandle) * (index + 1))) 1056 return NULL; 1057 1058 return of_find_node_by_phandle(be32_to_cpup(phandle + index)); 1059 } 1060 EXPORT_SYMBOL(of_parse_phandle); 1061 1062 /** 1063 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list 1064 * @np: pointer to a device tree node containing a list 1065 * @list_name: property name that contains a list 1066 * @cells_name: property name that specifies phandles' arguments count 1067 * @index: index of a phandle to parse out 1068 * @out_args: optional pointer to output arguments structure (will be filled) 1069 * 1070 * This function is useful to parse lists of phandles and their arguments. 1071 * Returns 0 on success and fills out_args, on error returns appropriate 1072 * errno value. 1073 * 1074 * Caller is responsible to call of_node_put() on the returned out_args->node 1075 * pointer. 1076 * 1077 * Example: 1078 * 1079 * phandle1: node1 { 1080 * #list-cells = <2>; 1081 * } 1082 * 1083 * phandle2: node2 { 1084 * #list-cells = <1>; 1085 * } 1086 * 1087 * node3 { 1088 * list = <&phandle1 1 2 &phandle2 3>; 1089 * } 1090 * 1091 * To get a device_node of the `node2' node you may call this: 1092 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args); 1093 */ 1094 static int __of_parse_phandle_with_args(const struct device_node *np, 1095 const char *list_name, 1096 const char *cells_name, int index, 1097 struct of_phandle_args *out_args) 1098 { 1099 const __be32 *list, *list_end; 1100 int rc = 0, size, cur_index = 0; 1101 uint32_t count = 0; 1102 struct device_node *node = NULL; 1103 phandle phandle; 1104 1105 /* Retrieve the phandle list property */ 1106 list = of_get_property(np, list_name, &size); 1107 if (!list) 1108 return -ENOENT; 1109 list_end = list + size / sizeof(*list); 1110 1111 /* Loop over the phandles until all the requested entry is found */ 1112 while (list < list_end) { 1113 rc = -EINVAL; 1114 count = 0; 1115 1116 /* 1117 * If phandle is 0, then it is an empty entry with no 1118 * arguments. Skip forward to the next entry. 1119 */ 1120 phandle = be32_to_cpup(list++); 1121 if (phandle) { 1122 /* 1123 * Find the provider node and parse the #*-cells 1124 * property to determine the argument length 1125 */ 1126 node = of_find_node_by_phandle(phandle); 1127 if (!node) { 1128 pr_err("%s: could not find phandle\n", 1129 np->full_name); 1130 goto err; 1131 } 1132 if (of_property_read_u32(node, cells_name, &count)) { 1133 pr_err("%s: could not get %s for %s\n", 1134 np->full_name, cells_name, 1135 node->full_name); 1136 goto err; 1137 } 1138 1139 /* 1140 * Make sure that the arguments actually fit in the 1141 * remaining property data length 1142 */ 1143 if (list + count > list_end) { 1144 pr_err("%s: arguments longer than property\n", 1145 np->full_name); 1146 goto err; 1147 } 1148 } 1149 1150 /* 1151 * All of the error cases above bail out of the loop, so at 1152 * this point, the parsing is successful. If the requested 1153 * index matches, then fill the out_args structure and return, 1154 * or return -ENOENT for an empty entry. 1155 */ 1156 rc = -ENOENT; 1157 if (cur_index == index) { 1158 if (!phandle) 1159 goto err; 1160 1161 if (out_args) { 1162 int i; 1163 if (WARN_ON(count > MAX_PHANDLE_ARGS)) 1164 count = MAX_PHANDLE_ARGS; 1165 out_args->np = node; 1166 out_args->args_count = count; 1167 for (i = 0; i < count; i++) 1168 out_args->args[i] = be32_to_cpup(list++); 1169 } 1170 1171 /* Found it! return success */ 1172 if (node) 1173 of_node_put(node); 1174 return 0; 1175 } 1176 1177 of_node_put(node); 1178 node = NULL; 1179 list += count; 1180 cur_index++; 1181 } 1182 1183 /* 1184 * Unlock node before returning result; will be one of: 1185 * -ENOENT : index is for empty phandle 1186 * -EINVAL : parsing error on data 1187 * [1..n] : Number of phandle (count mode; when index = -1) 1188 */ 1189 rc = index < 0 ? cur_index : -ENOENT; 1190 err: 1191 if (node) 1192 of_node_put(node); 1193 return rc; 1194 } 1195 1196 int of_parse_phandle_with_args(const struct device_node *np, const char *list_name, 1197 const char *cells_name, int index, 1198 struct of_phandle_args *out_args) 1199 { 1200 if (index < 0) 1201 return -EINVAL; 1202 return __of_parse_phandle_with_args(np, list_name, cells_name, index, out_args); 1203 } 1204 EXPORT_SYMBOL(of_parse_phandle_with_args); 1205 1206 /** 1207 * of_count_phandle_with_args() - Find the number of phandles references in a property 1208 * @np: pointer to a device tree node containing a list 1209 * @list_name: property name that contains a list 1210 * @cells_name: property name that specifies phandles' arguments count 1211 * 1212 * Returns the number of phandle + argument tuples within a property. It 1213 * is a typical pattern to encode a list of phandle and variable 1214 * arguments into a single property. The number of arguments is encoded 1215 * by a property in the phandle-target node. For example, a gpios 1216 * property would contain a list of GPIO specifies consisting of a 1217 * phandle and 1 or more arguments. The number of arguments are 1218 * determined by the #gpio-cells property in the node pointed to by the 1219 * phandle. 1220 */ 1221 int of_count_phandle_with_args(const struct device_node *np, const char *list_name, 1222 const char *cells_name) 1223 { 1224 return __of_parse_phandle_with_args(np, list_name, cells_name, -1, NULL); 1225 } 1226 EXPORT_SYMBOL(of_count_phandle_with_args); 1227 1228 #if defined(CONFIG_OF_DYNAMIC) 1229 static int of_property_notify(int action, struct device_node *np, 1230 struct property *prop) 1231 { 1232 struct of_prop_reconfig pr; 1233 1234 pr.dn = np; 1235 pr.prop = prop; 1236 return of_reconfig_notify(action, &pr); 1237 } 1238 #else 1239 static int of_property_notify(int action, struct device_node *np, 1240 struct property *prop) 1241 { 1242 return 0; 1243 } 1244 #endif 1245 1246 /** 1247 * of_add_property - Add a property to a node 1248 */ 1249 int of_add_property(struct device_node *np, struct property *prop) 1250 { 1251 struct property **next; 1252 unsigned long flags; 1253 int rc; 1254 1255 rc = of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop); 1256 if (rc) 1257 return rc; 1258 1259 prop->next = NULL; 1260 raw_spin_lock_irqsave(&devtree_lock, flags); 1261 next = &np->properties; 1262 while (*next) { 1263 if (strcmp(prop->name, (*next)->name) == 0) { 1264 /* duplicate ! don't insert it */ 1265 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1266 return -1; 1267 } 1268 next = &(*next)->next; 1269 } 1270 *next = prop; 1271 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1272 1273 #ifdef CONFIG_PROC_DEVICETREE 1274 /* try to add to proc as well if it was initialized */ 1275 if (np->pde) 1276 proc_device_tree_add_prop(np->pde, prop); 1277 #endif /* CONFIG_PROC_DEVICETREE */ 1278 1279 return 0; 1280 } 1281 1282 /** 1283 * of_remove_property - Remove a property from a node. 1284 * 1285 * Note that we don't actually remove it, since we have given out 1286 * who-knows-how-many pointers to the data using get-property. 1287 * Instead we just move the property to the "dead properties" 1288 * list, so it won't be found any more. 1289 */ 1290 int of_remove_property(struct device_node *np, struct property *prop) 1291 { 1292 struct property **next; 1293 unsigned long flags; 1294 int found = 0; 1295 int rc; 1296 1297 rc = of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1298 if (rc) 1299 return rc; 1300 1301 raw_spin_lock_irqsave(&devtree_lock, flags); 1302 next = &np->properties; 1303 while (*next) { 1304 if (*next == prop) { 1305 /* found the node */ 1306 *next = prop->next; 1307 prop->next = np->deadprops; 1308 np->deadprops = prop; 1309 found = 1; 1310 break; 1311 } 1312 next = &(*next)->next; 1313 } 1314 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1315 1316 if (!found) 1317 return -ENODEV; 1318 1319 #ifdef CONFIG_PROC_DEVICETREE 1320 /* try to remove the proc node as well */ 1321 if (np->pde) 1322 proc_device_tree_remove_prop(np->pde, prop); 1323 #endif /* CONFIG_PROC_DEVICETREE */ 1324 1325 return 0; 1326 } 1327 1328 /* 1329 * of_update_property - Update a property in a node, if the property does 1330 * not exist, add it. 1331 * 1332 * Note that we don't actually remove it, since we have given out 1333 * who-knows-how-many pointers to the data using get-property. 1334 * Instead we just move the property to the "dead properties" list, 1335 * and add the new property to the property list 1336 */ 1337 int of_update_property(struct device_node *np, struct property *newprop) 1338 { 1339 struct property **next, *oldprop; 1340 unsigned long flags; 1341 int rc, found = 0; 1342 1343 rc = of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop); 1344 if (rc) 1345 return rc; 1346 1347 if (!newprop->name) 1348 return -EINVAL; 1349 1350 oldprop = of_find_property(np, newprop->name, NULL); 1351 if (!oldprop) 1352 return of_add_property(np, newprop); 1353 1354 raw_spin_lock_irqsave(&devtree_lock, flags); 1355 next = &np->properties; 1356 while (*next) { 1357 if (*next == oldprop) { 1358 /* found the node */ 1359 newprop->next = oldprop->next; 1360 *next = newprop; 1361 oldprop->next = np->deadprops; 1362 np->deadprops = oldprop; 1363 found = 1; 1364 break; 1365 } 1366 next = &(*next)->next; 1367 } 1368 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1369 1370 if (!found) 1371 return -ENODEV; 1372 1373 #ifdef CONFIG_PROC_DEVICETREE 1374 /* try to add to proc as well if it was initialized */ 1375 if (np->pde) 1376 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1377 #endif /* CONFIG_PROC_DEVICETREE */ 1378 1379 return 0; 1380 } 1381 1382 #if defined(CONFIG_OF_DYNAMIC) 1383 /* 1384 * Support for dynamic device trees. 1385 * 1386 * On some platforms, the device tree can be manipulated at runtime. 1387 * The routines in this section support adding, removing and changing 1388 * device tree nodes. 1389 */ 1390 1391 static BLOCKING_NOTIFIER_HEAD(of_reconfig_chain); 1392 1393 int of_reconfig_notifier_register(struct notifier_block *nb) 1394 { 1395 return blocking_notifier_chain_register(&of_reconfig_chain, nb); 1396 } 1397 EXPORT_SYMBOL_GPL(of_reconfig_notifier_register); 1398 1399 int of_reconfig_notifier_unregister(struct notifier_block *nb) 1400 { 1401 return blocking_notifier_chain_unregister(&of_reconfig_chain, nb); 1402 } 1403 EXPORT_SYMBOL_GPL(of_reconfig_notifier_unregister); 1404 1405 int of_reconfig_notify(unsigned long action, void *p) 1406 { 1407 int rc; 1408 1409 rc = blocking_notifier_call_chain(&of_reconfig_chain, action, p); 1410 return notifier_to_errno(rc); 1411 } 1412 1413 #ifdef CONFIG_PROC_DEVICETREE 1414 static void of_add_proc_dt_entry(struct device_node *dn) 1415 { 1416 struct proc_dir_entry *ent; 1417 1418 ent = proc_mkdir(strrchr(dn->full_name, '/') + 1, dn->parent->pde); 1419 if (ent) 1420 proc_device_tree_add_node(dn, ent); 1421 } 1422 #else 1423 static void of_add_proc_dt_entry(struct device_node *dn) 1424 { 1425 return; 1426 } 1427 #endif 1428 1429 /** 1430 * of_attach_node - Plug a device node into the tree and global list. 1431 */ 1432 int of_attach_node(struct device_node *np) 1433 { 1434 unsigned long flags; 1435 int rc; 1436 1437 rc = of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, np); 1438 if (rc) 1439 return rc; 1440 1441 raw_spin_lock_irqsave(&devtree_lock, flags); 1442 np->sibling = np->parent->child; 1443 np->allnext = of_allnodes; 1444 np->parent->child = np; 1445 of_allnodes = np; 1446 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1447 1448 of_add_proc_dt_entry(np); 1449 return 0; 1450 } 1451 1452 #ifdef CONFIG_PROC_DEVICETREE 1453 static void of_remove_proc_dt_entry(struct device_node *dn) 1454 { 1455 struct device_node *parent = dn->parent; 1456 struct property *prop = dn->properties; 1457 1458 while (prop) { 1459 remove_proc_entry(prop->name, dn->pde); 1460 prop = prop->next; 1461 } 1462 1463 if (dn->pde) 1464 remove_proc_entry(dn->pde->name, parent->pde); 1465 } 1466 #else 1467 static void of_remove_proc_dt_entry(struct device_node *dn) 1468 { 1469 return; 1470 } 1471 #endif 1472 1473 /** 1474 * of_detach_node - "Unplug" a node from the device tree. 1475 * 1476 * The caller must hold a reference to the node. The memory associated with 1477 * the node is not freed until its refcount goes to zero. 1478 */ 1479 int of_detach_node(struct device_node *np) 1480 { 1481 struct device_node *parent; 1482 unsigned long flags; 1483 int rc = 0; 1484 1485 rc = of_reconfig_notify(OF_RECONFIG_DETACH_NODE, np); 1486 if (rc) 1487 return rc; 1488 1489 raw_spin_lock_irqsave(&devtree_lock, flags); 1490 1491 if (of_node_check_flag(np, OF_DETACHED)) { 1492 /* someone already detached it */ 1493 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1494 return rc; 1495 } 1496 1497 parent = np->parent; 1498 if (!parent) { 1499 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1500 return rc; 1501 } 1502 1503 if (of_allnodes == np) 1504 of_allnodes = np->allnext; 1505 else { 1506 struct device_node *prev; 1507 for (prev = of_allnodes; 1508 prev->allnext != np; 1509 prev = prev->allnext) 1510 ; 1511 prev->allnext = np->allnext; 1512 } 1513 1514 if (parent->child == np) 1515 parent->child = np->sibling; 1516 else { 1517 struct device_node *prevsib; 1518 for (prevsib = np->parent->child; 1519 prevsib->sibling != np; 1520 prevsib = prevsib->sibling) 1521 ; 1522 prevsib->sibling = np->sibling; 1523 } 1524 1525 of_node_set_flag(np, OF_DETACHED); 1526 raw_spin_unlock_irqrestore(&devtree_lock, flags); 1527 1528 of_remove_proc_dt_entry(np); 1529 return rc; 1530 } 1531 #endif /* defined(CONFIG_OF_DYNAMIC) */ 1532 1533 static void of_alias_add(struct alias_prop *ap, struct device_node *np, 1534 int id, const char *stem, int stem_len) 1535 { 1536 ap->np = np; 1537 ap->id = id; 1538 strncpy(ap->stem, stem, stem_len); 1539 ap->stem[stem_len] = 0; 1540 list_add_tail(&ap->link, &aliases_lookup); 1541 pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n", 1542 ap->alias, ap->stem, ap->id, of_node_full_name(np)); 1543 } 1544 1545 /** 1546 * of_alias_scan - Scan all properties of 'aliases' node 1547 * 1548 * The function scans all the properties of 'aliases' node and populate 1549 * the the global lookup table with the properties. It returns the 1550 * number of alias_prop found, or error code in error case. 1551 * 1552 * @dt_alloc: An allocator that provides a virtual address to memory 1553 * for the resulting tree 1554 */ 1555 void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)) 1556 { 1557 struct property *pp; 1558 1559 of_chosen = of_find_node_by_path("/chosen"); 1560 if (of_chosen == NULL) 1561 of_chosen = of_find_node_by_path("/chosen@0"); 1562 of_aliases = of_find_node_by_path("/aliases"); 1563 if (!of_aliases) 1564 return; 1565 1566 for_each_property_of_node(of_aliases, pp) { 1567 const char *start = pp->name; 1568 const char *end = start + strlen(start); 1569 struct device_node *np; 1570 struct alias_prop *ap; 1571 int id, len; 1572 1573 /* Skip those we do not want to proceed */ 1574 if (!strcmp(pp->name, "name") || 1575 !strcmp(pp->name, "phandle") || 1576 !strcmp(pp->name, "linux,phandle")) 1577 continue; 1578 1579 np = of_find_node_by_path(pp->value); 1580 if (!np) 1581 continue; 1582 1583 /* walk the alias backwards to extract the id and work out 1584 * the 'stem' string */ 1585 while (isdigit(*(end-1)) && end > start) 1586 end--; 1587 len = end - start; 1588 1589 if (kstrtoint(end, 10, &id) < 0) 1590 continue; 1591 1592 /* Allocate an alias_prop with enough space for the stem */ 1593 ap = dt_alloc(sizeof(*ap) + len + 1, 4); 1594 if (!ap) 1595 continue; 1596 ap->alias = start; 1597 of_alias_add(ap, np, id, start, len); 1598 } 1599 } 1600 1601 /** 1602 * of_alias_get_id - Get alias id for the given device_node 1603 * @np: Pointer to the given device_node 1604 * @stem: Alias stem of the given device_node 1605 * 1606 * The function travels the lookup table to get alias id for the given 1607 * device_node and alias stem. It returns the alias id if find it. 1608 */ 1609 int of_alias_get_id(struct device_node *np, const char *stem) 1610 { 1611 struct alias_prop *app; 1612 int id = -ENODEV; 1613 1614 mutex_lock(&of_aliases_mutex); 1615 list_for_each_entry(app, &aliases_lookup, link) { 1616 if (strcmp(app->stem, stem) != 0) 1617 continue; 1618 1619 if (np == app->np) { 1620 id = app->id; 1621 break; 1622 } 1623 } 1624 mutex_unlock(&of_aliases_mutex); 1625 1626 return id; 1627 } 1628 EXPORT_SYMBOL_GPL(of_alias_get_id); 1629 1630 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 1631 u32 *pu) 1632 { 1633 const void *curv = cur; 1634 1635 if (!prop) 1636 return NULL; 1637 1638 if (!cur) { 1639 curv = prop->value; 1640 goto out_val; 1641 } 1642 1643 curv += sizeof(*cur); 1644 if (curv >= prop->value + prop->length) 1645 return NULL; 1646 1647 out_val: 1648 *pu = be32_to_cpup(curv); 1649 return curv; 1650 } 1651 EXPORT_SYMBOL_GPL(of_prop_next_u32); 1652 1653 const char *of_prop_next_string(struct property *prop, const char *cur) 1654 { 1655 const void *curv = cur; 1656 1657 if (!prop) 1658 return NULL; 1659 1660 if (!cur) 1661 return prop->value; 1662 1663 curv += strlen(cur) + 1; 1664 if (curv >= prop->value + prop->length) 1665 return NULL; 1666 1667 return curv; 1668 } 1669 EXPORT_SYMBOL_GPL(of_prop_next_string); 1670