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