drivers/of/base.c

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