drivers/of/dynamic.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Support for dynamic device trees.
   4  *
   5  * On some platforms, the device tree can be manipulated at runtime.
   6  * The routines in this section support adding, removing and changing
   7  * device tree nodes.
   8  */
   9
  10 #define pr_fmt(fmt)     "OF: " fmt
  11
  12 #include <linux/of.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/slab.h>
  15 #include <linux/string.h>
  16 #include <linux/proc_fs.h>
  17
  18 #include "of_private.h"
  19
  20 static struct device_node *kobj_to_device_node(struct kobject *kobj)
  21 {
  22         return container_of(kobj, struct device_node, kobj);
  23 }
  24
  25 /**
  26  * of_node_get() - Increment refcount of a node
  27  * @node:       Node to inc refcount, NULL is supported to simplify writing of
  28  *              callers
  29  *
  30  * Return: The node with refcount incremented.
  31  */
  32 struct device_node *of_node_get(struct device_node *node)
  33 {
  34         if (node)
  35                 kobject_get(&node->kobj);
  36         return node;
  37 }
  38 EXPORT_SYMBOL(of_node_get);
  39
  40 /**
  41  * of_node_put() - Decrement refcount of a node
  42  * @node:       Node to dec refcount, NULL is supported to simplify writing of
  43  *              callers
  44  */
  45 void of_node_put(struct device_node *node)
  46 {
  47         if (node)
  48                 kobject_put(&node->kobj);
  49 }
  50 EXPORT_SYMBOL(of_node_put);
  51
  52 static BLOCKING_NOTIFIER_HEAD(of_reconfig_chain);
  53
  54 int of_reconfig_notifier_register(struct notifier_block *nb)
  55 {
  56         return blocking_notifier_chain_register(&of_reconfig_chain, nb);
  57 }
  58 EXPORT_SYMBOL_GPL(of_reconfig_notifier_register);
  59
  60 int of_reconfig_notifier_unregister(struct notifier_block *nb)
  61 {
  62         return blocking_notifier_chain_unregister(&of_reconfig_chain, nb);
  63 }
  64 EXPORT_SYMBOL_GPL(of_reconfig_notifier_unregister);
  65
  66 static const char *action_names[] = {
  67         [0] = "INVALID",
  68         [OF_RECONFIG_ATTACH_NODE] = "ATTACH_NODE",
  69         [OF_RECONFIG_DETACH_NODE] = "DETACH_NODE",
  70         [OF_RECONFIG_ADD_PROPERTY] = "ADD_PROPERTY",
  71         [OF_RECONFIG_REMOVE_PROPERTY] = "REMOVE_PROPERTY",
  72         [OF_RECONFIG_UPDATE_PROPERTY] = "UPDATE_PROPERTY",
  73 };
  74
  75 #define _do_print(func, prefix, action, node, prop, ...) ({     \
  76         func("changeset: " prefix "%-15s %pOF%s%s\n",           \
  77              ##__VA_ARGS__, action_names[action], node,         \
  78              prop ? ":" : "", prop ? prop->name : "");          \
  79 })
  80 #define of_changeset_action_err(...) _do_print(pr_err, __VA_ARGS__)
  81 #define of_changeset_action_debug(...) _do_print(pr_debug, __VA_ARGS__)
  82
  83 int of_reconfig_notify(unsigned long action, struct of_reconfig_data *p)
  84 {
  85         int rc;
  86         struct of_reconfig_data *pr = p;
  87
  88         of_changeset_action_debug("notify: ", action, pr->dn, pr->prop);
  89
  90         rc = blocking_notifier_call_chain(&of_reconfig_chain, action, p);
  91         return notifier_to_errno(rc);
  92 }
  93
  94 /*
  95  * of_reconfig_get_state_change()       - Returns new state of device
  96  * @action      - action of the of notifier
  97  * @arg         - argument of the of notifier
  98  *
  99  * Returns the new state of a device based on the notifier used.
 100  *
 101  * Return: OF_RECONFIG_CHANGE_REMOVE on device going from enabled to
 102  * disabled, OF_RECONFIG_CHANGE_ADD on device going from disabled to
 103  * enabled and OF_RECONFIG_NO_CHANGE on no change.
 104  */
 105 int of_reconfig_get_state_change(unsigned long action, struct of_reconfig_data *pr)
 106 {
 107         struct property *prop, *old_prop = NULL;
 108         int is_status, status_state, old_status_state, prev_state, new_state;
 109
 110         /* figure out if a device should be created or destroyed */
 111         switch (action) {
 112         case OF_RECONFIG_ATTACH_NODE:
 113         case OF_RECONFIG_DETACH_NODE:
 114                 prop = of_find_property(pr->dn, "status", NULL);
 115                 break;
 116         case OF_RECONFIG_ADD_PROPERTY:
 117         case OF_RECONFIG_REMOVE_PROPERTY:
 118                 prop = pr->prop;
 119                 break;
 120         case OF_RECONFIG_UPDATE_PROPERTY:
 121                 prop = pr->prop;
 122                 old_prop = pr->old_prop;
 123                 break;
 124         default:
 125                 return OF_RECONFIG_NO_CHANGE;
 126         }
 127
 128         is_status = 0;
 129         status_state = -1;
 130         old_status_state = -1;
 131         prev_state = -1;
 132         new_state = -1;
 133
 134         if (prop && !strcmp(prop->name, "status")) {
 135                 is_status = 1;
 136                 status_state = !strcmp(prop->value, "okay") ||
 137                                !strcmp(prop->value, "ok");
 138                 if (old_prop)
 139                         old_status_state = !strcmp(old_prop->value, "okay") ||
 140                                            !strcmp(old_prop->value, "ok");
 141         }
 142
 143         switch (action) {
 144         case OF_RECONFIG_ATTACH_NODE:
 145                 prev_state = 0;
 146                 /* -1 & 0 status either missing or okay */
 147                 new_state = status_state != 0;
 148                 break;
 149         case OF_RECONFIG_DETACH_NODE:
 150                 /* -1 & 0 status either missing or okay */
 151                 prev_state = status_state != 0;
 152                 new_state = 0;
 153                 break;
 154         case OF_RECONFIG_ADD_PROPERTY:
 155                 if (is_status) {
 156                         /* no status property -> enabled (legacy) */
 157                         prev_state = 1;
 158                         new_state = status_state;
 159                 }
 160                 break;
 161         case OF_RECONFIG_REMOVE_PROPERTY:
 162                 if (is_status) {
 163                         prev_state = status_state;
 164                         /* no status property -> enabled (legacy) */
 165                         new_state = 1;
 166                 }
 167                 break;
 168         case OF_RECONFIG_UPDATE_PROPERTY:
 169                 if (is_status) {
 170                         prev_state = old_status_state != 0;
 171                         new_state = status_state != 0;
 172                 }
 173                 break;
 174         }
 175
 176         if (prev_state == new_state)
 177                 return OF_RECONFIG_NO_CHANGE;
 178
 179         return new_state ? OF_RECONFIG_CHANGE_ADD : OF_RECONFIG_CHANGE_REMOVE;
 180 }
 181 EXPORT_SYMBOL_GPL(of_reconfig_get_state_change);
 182
 183 int of_property_notify(int action, struct device_node *np,
 184                        struct property *prop, struct property *oldprop)
 185 {
 186         struct of_reconfig_data pr;
 187
 188         /* only call notifiers if the node is attached */
 189         if (!of_node_is_attached(np))
 190                 return 0;
 191
 192         pr.dn = np;
 193         pr.prop = prop;
 194         pr.old_prop = oldprop;
 195         return of_reconfig_notify(action, &pr);
 196 }
 197
 198 static void __of_attach_node(struct device_node *np)
 199 {
 200         const __be32 *phandle;
 201         int sz;
 202         unsigned long flags;
 203
 204         raw_spin_lock_irqsave(&devtree_lock, flags);
 205
 206         if (!of_node_check_flag(np, OF_OVERLAY)) {
 207                 np->name = __of_get_property(np, "name", NULL);
 208                 if (!np->name)
 209                         np->name = "<NULL>";
 210
 211                 phandle = __of_get_property(np, "phandle", &sz);
 212                 if (!phandle)
 213                         phandle = __of_get_property(np, "linux,phandle", &sz);
 214                 if (IS_ENABLED(CONFIG_PPC_PSERIES) && !phandle)
 215                         phandle = __of_get_property(np, "ibm,phandle", &sz);
 216                 if (phandle && (sz >= 4))
 217                         np->phandle = be32_to_cpup(phandle);
 218                 else
 219                         np->phandle = 0;
 220         }
 221
 222         np->child = NULL;
 223         np->sibling = np->parent->child;
 224         np->parent->child = np;
 225         of_node_clear_flag(np, OF_DETACHED);
 226         np->fwnode.flags |= FWNODE_FLAG_NOT_DEVICE;
 227
 228         raw_spin_unlock_irqrestore(&devtree_lock, flags);
 229
 230         __of_attach_node_sysfs(np);
 231 }
 232
 233 /**
 234  * of_attach_node() - Plug a device node into the tree and global list.
 235  * @np:         Pointer to the caller's Device Node
 236  */
 237 int of_attach_node(struct device_node *np)
 238 {
 239         struct of_reconfig_data rd;
 240
 241         memset(&rd, 0, sizeof(rd));
 242         rd.dn = np;
 243
 244         mutex_lock(&of_mutex);
 245         __of_attach_node(np);
 246         mutex_unlock(&of_mutex);
 247
 248         of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, &rd);
 249
 250         return 0;
 251 }
 252
 253 void __of_detach_node(struct device_node *np)
 254 {
 255         struct device_node *parent;
 256         unsigned long flags;
 257
 258         raw_spin_lock_irqsave(&devtree_lock, flags);
 259
 260         parent = np->parent;
 261         if (WARN_ON(of_node_check_flag(np, OF_DETACHED) || !parent)) {
 262                 raw_spin_unlock_irqrestore(&devtree_lock, flags);
 263                 return;
 264         }
 265
 266         if (parent->child == np)
 267                 parent->child = np->sibling;
 268         else {
 269                 struct device_node *prevsib;
 270                 for (prevsib = np->parent->child;
 271                      prevsib->sibling != np;
 272                      prevsib = prevsib->sibling)
 273                         ;
 274                 prevsib->sibling = np->sibling;
 275         }
 276
 277         of_node_set_flag(np, OF_DETACHED);
 278
 279         /* race with of_find_node_by_phandle() prevented by devtree_lock */
 280         __of_phandle_cache_inv_entry(np->phandle);
 281
 282         raw_spin_unlock_irqrestore(&devtree_lock, flags);
 283
 284         __of_detach_node_sysfs(np);
 285 }
 286
 287 /**
 288  * of_detach_node() - "Unplug" a node from the device tree.
 289  * @np:         Pointer to the caller's Device Node
 290  */
 291 int of_detach_node(struct device_node *np)
 292 {
 293         struct of_reconfig_data rd;
 294
 295         memset(&rd, 0, sizeof(rd));
 296         rd.dn = np;
 297
 298         mutex_lock(&of_mutex);
 299         __of_detach_node(np);
 300         mutex_unlock(&of_mutex);
 301
 302         of_reconfig_notify(OF_RECONFIG_DETACH_NODE, &rd);
 303
 304         return 0;
 305 }
 306 EXPORT_SYMBOL_GPL(of_detach_node);
 307
 308 static void property_list_free(struct property *prop_list)
 309 {
 310         struct property *prop, *next;
 311
 312         for (prop = prop_list; prop != NULL; prop = next) {
 313                 next = prop->next;
 314                 kfree(prop->name);
 315                 kfree(prop->value);
 316                 kfree(prop);
 317         }
 318 }
 319
 320 /**
 321  * of_node_release() - release a dynamically allocated node
 322  * @kobj: kernel object of the node to be released
 323  *
 324  * In of_node_put() this function is passed to kref_put() as the destructor.
 325  */
 326 void of_node_release(struct kobject *kobj)
 327 {
 328         struct device_node *node = kobj_to_device_node(kobj);
 329
 330         /*
 331          * can not use '"%pOF", node' in pr_err() calls from this function
 332          * because an of_node_get(node) when refcount is already zero
 333          * will result in an error and a stack dump
 334          */
 335
 336         /* We should never be releasing nodes that haven't been detached. */
 337         if (!of_node_check_flag(node, OF_DETACHED)) {
 338
 339                 pr_err("ERROR: %s() detected bad of_node_put() on %pOF/%s\n",
 340                         __func__, node->parent, node->full_name);
 341
 342                 /*
 343                  * of unittests will test this path.  Do not print the stack
 344                  * trace when the error is caused by unittest so that we do
 345                  * not display what a normal developer might reasonably
 346                  * consider a real bug.
 347                  */
 348                 if (!IS_ENABLED(CONFIG_OF_UNITTEST) ||
 349                     strcmp(node->parent->full_name, "testcase-data")) {
 350                         dump_stack();
 351                         pr_err("ERROR: next of_node_put() on this node will result in a kobject warning 'refcount_t: underflow; use-after-free.'\n");
 352                 }
 353
 354                 return;
 355         }
 356         if (!of_node_check_flag(node, OF_DYNAMIC))
 357                 return;
 358
 359         if (of_node_check_flag(node, OF_OVERLAY)) {
 360
 361                 if (!of_node_check_flag(node, OF_OVERLAY_FREE_CSET)) {
 362                         /* premature refcount of zero, do not free memory */
 363                         pr_err("ERROR: memory leak before free overlay changeset,  %pOF\n",
 364                                node);
 365                         return;
 366                 }
 367
 368                 /*
 369                  * If node->properties non-empty then properties were added
 370                  * to this node either by different overlay that has not
 371                  * yet been removed, or by a non-overlay mechanism.
 372                  */
 373                 if (node->properties)
 374                         pr_err("ERROR: %s(), unexpected properties in %pOF\n",
 375                                __func__, node);
 376         }
 377
 378         if (node->child)
 379                 pr_err("ERROR: %s() unexpected children for %pOF/%s\n",
 380                         __func__, node->parent, node->full_name);
 381
 382         property_list_free(node->properties);
 383         property_list_free(node->deadprops);
 384         fwnode_links_purge(of_fwnode_handle(node));
 385
 386         kfree(node->full_name);
 387         kfree(node->data);
 388         kfree(node);
 389 }
 390
 391 /**
 392  * __of_prop_dup - Copy a property dynamically.
 393  * @prop:       Property to copy
 394  * @allocflags: Allocation flags (typically pass GFP_KERNEL)
 395  *
 396  * Copy a property by dynamically allocating the memory of both the
 397  * property structure and the property name & contents. The property's
 398  * flags have the OF_DYNAMIC bit set so that we can differentiate between
 399  * dynamically allocated properties and not.
 400  *
 401  * Return: The newly allocated property or NULL on out of memory error.
 402  */
 403 struct property *__of_prop_dup(const struct property *prop, gfp_t allocflags)
 404 {
 405         struct property *new;
 406
 407         new = kzalloc(sizeof(*new), allocflags);
 408         if (!new)
 409                 return NULL;
 410
 411         /*
 412          * NOTE: There is no check for zero length value.
 413          * In case of a boolean property, this will allocate a value
 414          * of zero bytes. We do this to work around the use
 415          * of of_get_property() calls on boolean values.
 416          */
 417         new->name = kstrdup(prop->name, allocflags);
 418         new->value = kmemdup(prop->value, prop->length, allocflags);
 419         new->length = prop->length;
 420         if (!new->name || !new->value)
 421                 goto err_free;
 422
 423         /* mark the property as dynamic */
 424         of_property_set_flag(new, OF_DYNAMIC);
 425
 426         return new;
 427
 428  err_free:
 429         kfree(new->name);
 430         kfree(new->value);
 431         kfree(new);
 432         return NULL;
 433 }
 434
 435 /**
 436  * __of_node_dup() - Duplicate or create an empty device node dynamically.
 437  * @np:         if not NULL, contains properties to be duplicated in new node
 438  * @full_name:  string value to be duplicated into new node's full_name field
 439  *
 440  * Create a device tree node, optionally duplicating the properties of
 441  * another node.  The node data are dynamically allocated and all the node
 442  * flags have the OF_DYNAMIC & OF_DETACHED bits set.
 443  *
 444  * Return: The newly allocated node or NULL on out of memory error.  Use
 445  * of_node_put() on it when done to free the memory allocated for it.
 446  */
 447 struct device_node *__of_node_dup(const struct device_node *np,
 448                                   const char *full_name)
 449 {
 450         struct device_node *node;
 451
 452         node = kzalloc(sizeof(*node), GFP_KERNEL);
 453         if (!node)
 454                 return NULL;
 455         node->full_name = kstrdup(full_name, GFP_KERNEL);
 456         if (!node->full_name) {
 457                 kfree(node);
 458                 return NULL;
 459         }
 460
 461         of_node_set_flag(node, OF_DYNAMIC);
 462         of_node_set_flag(node, OF_DETACHED);
 463         of_node_init(node);
 464
 465         /* Iterate over and duplicate all properties */
 466         if (np) {
 467                 struct property *pp, *new_pp;
 468                 for_each_property_of_node(np, pp) {
 469                         new_pp = __of_prop_dup(pp, GFP_KERNEL);
 470                         if (!new_pp)
 471                                 goto err_prop;
 472                         if (__of_add_property(node, new_pp)) {
 473                                 kfree(new_pp->name);
 474                                 kfree(new_pp->value);
 475                                 kfree(new_pp);
 476                                 goto err_prop;
 477                         }
 478                 }
 479         }
 480         return node;
 481
 482  err_prop:
 483         of_node_put(node); /* Frees the node and properties */
 484         return NULL;
 485 }
 486
 487 /**
 488  * of_changeset_create_node - Dynamically create a device node and attach to
 489  * a given changeset.
 490  *
 491  * @ocs: Pointer to changeset
 492  * @parent: Pointer to parent device node
 493  * @full_name: Node full name
 494  *
 495  * Return: Pointer to the created device node or NULL in case of an error.
 496  */
 497 struct device_node *of_changeset_create_node(struct of_changeset *ocs,
 498                                              struct device_node *parent,
 499                                              const char *full_name)
 500 {
 501         struct device_node *np;
 502         int ret;
 503
 504         np = __of_node_dup(NULL, full_name);
 505         if (!np)
 506                 return NULL;
 507         np->parent = parent;
 508
 509         ret = of_changeset_attach_node(ocs, np);
 510         if (ret) {
 511                 of_node_put(np);
 512                 return NULL;
 513         }
 514
 515         return np;
 516 }
 517 EXPORT_SYMBOL(of_changeset_create_node);
 518
 519 static void __of_changeset_entry_destroy(struct of_changeset_entry *ce)
 520 {
 521         if (ce->action == OF_RECONFIG_ATTACH_NODE &&
 522             of_node_check_flag(ce->np, OF_OVERLAY)) {
 523                 if (kref_read(&ce->np->kobj.kref) > 1) {
 524                         pr_err("ERROR: memory leak, expected refcount 1 instead of %d, of_node_get()/of_node_put() unbalanced - destroy cset entry: attach overlay node %pOF\n",
 525                                kref_read(&ce->np->kobj.kref), ce->np);
 526                 } else {
 527                         of_node_set_flag(ce->np, OF_OVERLAY_FREE_CSET);
 528                 }
 529         }
 530
 531         of_node_put(ce->np);
 532         list_del(&ce->node);
 533         kfree(ce);
 534 }
 535
 536 static void __of_changeset_entry_invert(struct of_changeset_entry *ce,
 537                                           struct of_changeset_entry *rce)
 538 {
 539         memcpy(rce, ce, sizeof(*rce));
 540
 541         switch (ce->action) {
 542         case OF_RECONFIG_ATTACH_NODE:
 543                 rce->action = OF_RECONFIG_DETACH_NODE;
 544                 break;
 545         case OF_RECONFIG_DETACH_NODE:
 546                 rce->action = OF_RECONFIG_ATTACH_NODE;
 547                 break;
 548         case OF_RECONFIG_ADD_PROPERTY:
 549                 rce->action = OF_RECONFIG_REMOVE_PROPERTY;
 550                 break;
 551         case OF_RECONFIG_REMOVE_PROPERTY:
 552                 rce->action = OF_RECONFIG_ADD_PROPERTY;
 553                 break;
 554         case OF_RECONFIG_UPDATE_PROPERTY:
 555                 rce->old_prop = ce->prop;
 556                 rce->prop = ce->old_prop;
 557                 /* update was used but original property did not exist */
 558                 if (!rce->prop) {
 559                         rce->action = OF_RECONFIG_REMOVE_PROPERTY;
 560                         rce->prop = ce->prop;
 561                 }
 562                 break;
 563         }
 564 }
 565
 566 static int __of_changeset_entry_notify(struct of_changeset_entry *ce,
 567                 bool revert)
 568 {
 569         struct of_reconfig_data rd;
 570         struct of_changeset_entry ce_inverted;
 571         int ret = 0;
 572
 573         if (revert) {
 574                 __of_changeset_entry_invert(ce, &ce_inverted);
 575                 ce = &ce_inverted;
 576         }
 577
 578         switch (ce->action) {
 579         case OF_RECONFIG_ATTACH_NODE:
 580         case OF_RECONFIG_DETACH_NODE:
 581                 memset(&rd, 0, sizeof(rd));
 582                 rd.dn = ce->np;
 583                 ret = of_reconfig_notify(ce->action, &rd);
 584                 break;
 585         case OF_RECONFIG_ADD_PROPERTY:
 586         case OF_RECONFIG_REMOVE_PROPERTY:
 587         case OF_RECONFIG_UPDATE_PROPERTY:
 588                 ret = of_property_notify(ce->action, ce->np, ce->prop, ce->old_prop);
 589                 break;
 590         default:
 591                 pr_err("invalid devicetree changeset action: %i\n",
 592                         (int)ce->action);
 593                 ret = -EINVAL;
 594         }
 595
 596         if (ret)
 597                 pr_err("changeset notifier error @%pOF\n", ce->np);
 598         return ret;
 599 }
 600
 601 static int __of_changeset_entry_apply(struct of_changeset_entry *ce)
 602 {
 603         int ret = 0;
 604
 605         of_changeset_action_debug("apply: ", ce->action, ce->np, ce->prop);
 606
 607         switch (ce->action) {
 608         case OF_RECONFIG_ATTACH_NODE:
 609                 __of_attach_node(ce->np);
 610                 break;
 611         case OF_RECONFIG_DETACH_NODE:
 612                 __of_detach_node(ce->np);
 613                 break;
 614         case OF_RECONFIG_ADD_PROPERTY:
 615                 ret = __of_add_property(ce->np, ce->prop);
 616                 break;
 617         case OF_RECONFIG_REMOVE_PROPERTY:
 618                 ret = __of_remove_property(ce->np, ce->prop);
 619                 break;
 620
 621         case OF_RECONFIG_UPDATE_PROPERTY:
 622                 ret = __of_update_property(ce->np, ce->prop, &ce->old_prop);
 623                 break;
 624         default:
 625                 ret = -EINVAL;
 626         }
 627
 628         if (ret) {
 629                 of_changeset_action_err("apply failed: ", ce->action, ce->np, ce->prop);
 630                 return ret;
 631         }
 632
 633         return 0;
 634 }
 635
 636 static inline int __of_changeset_entry_revert(struct of_changeset_entry *ce)
 637 {
 638         struct of_changeset_entry ce_inverted;
 639
 640         __of_changeset_entry_invert(ce, &ce_inverted);
 641         return __of_changeset_entry_apply(&ce_inverted);
 642 }
 643
 644 /**
 645  * of_changeset_init - Initialize a changeset for use
 646  *
 647  * @ocs:        changeset pointer
 648  *
 649  * Initialize a changeset structure
 650  */
 651 void of_changeset_init(struct of_changeset *ocs)
 652 {
 653         memset(ocs, 0, sizeof(*ocs));
 654         INIT_LIST_HEAD(&ocs->entries);
 655 }
 656 EXPORT_SYMBOL_GPL(of_changeset_init);
 657
 658 /**
 659  * of_changeset_destroy - Destroy a changeset
 660  *
 661  * @ocs:        changeset pointer
 662  *
 663  * Destroys a changeset. Note that if a changeset is applied,
 664  * its changes to the tree cannot be reverted.
 665  */
 666 void of_changeset_destroy(struct of_changeset *ocs)
 667 {
 668         struct of_changeset_entry *ce, *cen;
 669
 670         list_for_each_entry_safe_reverse(ce, cen, &ocs->entries, node)
 671                 __of_changeset_entry_destroy(ce);
 672 }
 673 EXPORT_SYMBOL_GPL(of_changeset_destroy);
 674
 675 /*
 676  * Apply the changeset entries in @ocs.
 677  * If apply fails, an attempt is made to revert the entries that were
 678  * successfully applied.
 679  *
 680  * If multiple revert errors occur then only the final revert error is reported.
 681  *
 682  * Returns 0 on success, a negative error value in case of an error.
 683  * If a revert error occurs, it is returned in *ret_revert.
 684  */
 685 int __of_changeset_apply_entries(struct of_changeset *ocs, int *ret_revert)
 686 {
 687         struct of_changeset_entry *ce;
 688         int ret, ret_tmp;
 689
 690         pr_debug("changeset: applying...\n");
 691         list_for_each_entry(ce, &ocs->entries, node) {
 692                 ret = __of_changeset_entry_apply(ce);
 693                 if (ret) {
 694                         pr_err("Error applying changeset (%d)\n", ret);
 695                         list_for_each_entry_continue_reverse(ce, &ocs->entries,
 696                                                              node) {
 697                                 ret_tmp = __of_changeset_entry_revert(ce);
 698                                 if (ret_tmp)
 699                                         *ret_revert = ret_tmp;
 700                         }
 701                         return ret;
 702                 }
 703         }
 704
 705         return 0;
 706 }
 707
 708 /*
 709  * Returns 0 on success, a negative error value in case of an error.
 710  *
 711  * If multiple changeset entry notification errors occur then only the
 712  * final notification error is reported.
 713  */
 714 int __of_changeset_apply_notify(struct of_changeset *ocs)
 715 {
 716         struct of_changeset_entry *ce;
 717         int ret = 0, ret_tmp;
 718
 719         pr_debug("changeset: emitting notifiers.\n");
 720
 721         /* drop the global lock while emitting notifiers */
 722         mutex_unlock(&of_mutex);
 723         list_for_each_entry(ce, &ocs->entries, node) {
 724                 ret_tmp = __of_changeset_entry_notify(ce, 0);
 725                 if (ret_tmp)
 726                         ret = ret_tmp;
 727         }
 728         mutex_lock(&of_mutex);
 729         pr_debug("changeset: notifiers sent.\n");
 730
 731         return ret;
 732 }
 733
 734 /*
 735  * Returns 0 on success, a negative error value in case of an error.
 736  *
 737  * If a changeset entry apply fails, an attempt is made to revert any
 738  * previous entries in the changeset.  If any of the reverts fails,
 739  * that failure is not reported.  Thus the state of the device tree
 740  * is unknown if an apply error occurs.
 741  */
 742 static int __of_changeset_apply(struct of_changeset *ocs)
 743 {
 744         int ret, ret_revert = 0;
 745
 746         ret = __of_changeset_apply_entries(ocs, &ret_revert);
 747         if (!ret)
 748                 ret = __of_changeset_apply_notify(ocs);
 749
 750         return ret;
 751 }
 752
 753 /**
 754  * of_changeset_apply - Applies a changeset
 755  *
 756  * @ocs:        changeset pointer
 757  *
 758  * Applies a changeset to the live tree.
 759  * Any side-effects of live tree state changes are applied here on
 760  * success, like creation/destruction of devices and side-effects
 761  * like creation of sysfs properties and directories.
 762  *
 763  * Return: 0 on success, a negative error value in case of an error.
 764  * On error the partially applied effects are reverted.
 765  */
 766 int of_changeset_apply(struct of_changeset *ocs)
 767 {
 768         int ret;
 769
 770         mutex_lock(&of_mutex);
 771         ret = __of_changeset_apply(ocs);
 772         mutex_unlock(&of_mutex);
 773
 774         return ret;
 775 }
 776 EXPORT_SYMBOL_GPL(of_changeset_apply);
 777
 778 /*
 779  * Revert the changeset entries in @ocs.
 780  * If revert fails, an attempt is made to re-apply the entries that were
 781  * successfully removed.
 782  *
 783  * If multiple re-apply errors occur then only the final apply error is
 784  * reported.
 785  *
 786  * Returns 0 on success, a negative error value in case of an error.
 787  * If an apply error occurs, it is returned in *ret_apply.
 788  */
 789 int __of_changeset_revert_entries(struct of_changeset *ocs, int *ret_apply)
 790 {
 791         struct of_changeset_entry *ce;
 792         int ret, ret_tmp;
 793
 794         pr_debug("changeset: reverting...\n");
 795         list_for_each_entry_reverse(ce, &ocs->entries, node) {
 796                 ret = __of_changeset_entry_revert(ce);
 797                 if (ret) {
 798                         pr_err("Error reverting changeset (%d)\n", ret);
 799                         list_for_each_entry_continue(ce, &ocs->entries, node) {
 800                                 ret_tmp = __of_changeset_entry_apply(ce);
 801                                 if (ret_tmp)
 802                                         *ret_apply = ret_tmp;
 803                         }
 804                         return ret;
 805                 }
 806         }
 807
 808         return 0;
 809 }
 810
 811 /*
 812  * If multiple changeset entry notification errors occur then only the
 813  * final notification error is reported.
 814  */
 815 int __of_changeset_revert_notify(struct of_changeset *ocs)
 816 {
 817         struct of_changeset_entry *ce;
 818         int ret = 0, ret_tmp;
 819
 820         pr_debug("changeset: emitting notifiers.\n");
 821
 822         /* drop the global lock while emitting notifiers */
 823         mutex_unlock(&of_mutex);
 824         list_for_each_entry_reverse(ce, &ocs->entries, node) {
 825                 ret_tmp = __of_changeset_entry_notify(ce, 1);
 826                 if (ret_tmp)
 827                         ret = ret_tmp;
 828         }
 829         mutex_lock(&of_mutex);
 830         pr_debug("changeset: notifiers sent.\n");
 831
 832         return ret;
 833 }
 834
 835 static int __of_changeset_revert(struct of_changeset *ocs)
 836 {
 837         int ret, ret_reply;
 838
 839         ret_reply = 0;
 840         ret = __of_changeset_revert_entries(ocs, &ret_reply);
 841
 842         if (!ret)
 843                 ret = __of_changeset_revert_notify(ocs);
 844
 845         return ret;
 846 }
 847
 848 /**
 849  * of_changeset_revert - Reverts an applied changeset
 850  *
 851  * @ocs:        changeset pointer
 852  *
 853  * Reverts a changeset returning the state of the tree to what it
 854  * was before the application.
 855  * Any side-effects like creation/destruction of devices and
 856  * removal of sysfs properties and directories are applied.
 857  *
 858  * Return: 0 on success, a negative error value in case of an error.
 859  */
 860 int of_changeset_revert(struct of_changeset *ocs)
 861 {
 862         int ret;
 863
 864         mutex_lock(&of_mutex);
 865         ret = __of_changeset_revert(ocs);
 866         mutex_unlock(&of_mutex);
 867
 868         return ret;
 869 }
 870 EXPORT_SYMBOL_GPL(of_changeset_revert);
 871
 872 /**
 873  * of_changeset_action - Add an action to the tail of the changeset list
 874  *
 875  * @ocs:        changeset pointer
 876  * @action:     action to perform
 877  * @np:         Pointer to device node
 878  * @prop:       Pointer to property
 879  *
 880  * On action being one of:
 881  * + OF_RECONFIG_ATTACH_NODE
 882  * + OF_RECONFIG_DETACH_NODE,
 883  * + OF_RECONFIG_ADD_PROPERTY
 884  * + OF_RECONFIG_REMOVE_PROPERTY,
 885  * + OF_RECONFIG_UPDATE_PROPERTY
 886  *
 887  * Return: 0 on success, a negative error value in case of an error.
 888  */
 889 int of_changeset_action(struct of_changeset *ocs, unsigned long action,
 890                 struct device_node *np, struct property *prop)
 891 {
 892         struct of_changeset_entry *ce;
 893
 894         if (WARN_ON(action >= ARRAY_SIZE(action_names)))
 895                 return -EINVAL;
 896
 897         ce = kzalloc(sizeof(*ce), GFP_KERNEL);
 898         if (!ce)
 899                 return -ENOMEM;
 900
 901         /* get a reference to the node */
 902         ce->action = action;
 903         ce->np = of_node_get(np);
 904         ce->prop = prop;
 905
 906         /* add it to the list */
 907         list_add_tail(&ce->node, &ocs->entries);
 908         return 0;
 909 }
 910 EXPORT_SYMBOL_GPL(of_changeset_action);
 911
 912 static int of_changeset_add_prop_helper(struct of_changeset *ocs,
 913                                         struct device_node *np,
 914                                         const struct property *pp)
 915 {
 916         struct property *new_pp;
 917         int ret;
 918
 919         new_pp = __of_prop_dup(pp, GFP_KERNEL);
 920         if (!new_pp)
 921                 return -ENOMEM;
 922
 923         ret = of_changeset_add_property(ocs, np, new_pp);
 924         if (ret) {
 925                 kfree(new_pp->name);
 926                 kfree(new_pp->value);
 927                 kfree(new_pp);
 928         }
 929
 930         return ret;
 931 }
 932
 933 /**
 934  * of_changeset_add_prop_string - Add a string property to a changeset
 935  *
 936  * @ocs:        changeset pointer
 937  * @np:         device node pointer
 938  * @prop_name:  name of the property to be added
 939  * @str:        pointer to null terminated string
 940  *
 941  * Create a string property and add it to a changeset.
 942  *
 943  * Return: 0 on success, a negative error value in case of an error.
 944  */
 945 int of_changeset_add_prop_string(struct of_changeset *ocs,
 946                                  struct device_node *np,
 947                                  const char *prop_name, const char *str)
 948 {
 949         struct property prop;
 950
 951         prop.name = (char *)prop_name;
 952         prop.length = strlen(str) + 1;
 953         prop.value = (void *)str;
 954
 955         return of_changeset_add_prop_helper(ocs, np, &prop);
 956 }
 957 EXPORT_SYMBOL_GPL(of_changeset_add_prop_string);
 958
 959 /**
 960  * of_changeset_add_prop_string_array - Add a string list property to
 961  * a changeset
 962  *
 963  * @ocs:        changeset pointer
 964  * @np:         device node pointer
 965  * @prop_name:  name of the property to be added
 966  * @str_array:  pointer to an array of null terminated strings
 967  * @sz:         number of string array elements
 968  *
 969  * Create a string list property and add it to a changeset.
 970  *
 971  * Return: 0 on success, a negative error value in case of an error.
 972  */
 973 int of_changeset_add_prop_string_array(struct of_changeset *ocs,
 974                                        struct device_node *np,
 975                                        const char *prop_name,
 976                                        const char **str_array, size_t sz)
 977 {
 978         struct property prop;
 979         int i, ret;
 980         char *vp;
 981
 982         prop.name = (char *)prop_name;
 983
 984         prop.length = 0;
 985         for (i = 0; i < sz; i++)
 986                 prop.length += strlen(str_array[i]) + 1;
 987
 988         prop.value = kmalloc(prop.length, GFP_KERNEL);
 989         if (!prop.value)
 990                 return -ENOMEM;
 991
 992         vp = prop.value;
 993         for (i = 0; i < sz; i++) {
 994                 vp += snprintf(vp, (char *)prop.value + prop.length - vp, "%s",
 995                                str_array[i]) + 1;
 996         }
 997         ret = of_changeset_add_prop_helper(ocs, np, &prop);
 998         kfree(prop.value);
 999
1000         return ret;
1001 }
1002 EXPORT_SYMBOL_GPL(of_changeset_add_prop_string_array);
1003
1004 /**
1005  * of_changeset_add_prop_u32_array - Add a property of 32 bit integers
1006  * property to a changeset
1007  *
1008  * @ocs:        changeset pointer
1009  * @np:         device node pointer
1010  * @prop_name:  name of the property to be added
1011  * @array:      pointer to an array of 32 bit integers
1012  * @sz:         number of array elements
1013  *
1014  * Create a property of 32 bit integers and add it to a changeset.
1015  *
1016  * Return: 0 on success, a negative error value in case of an error.
1017  */
1018 int of_changeset_add_prop_u32_array(struct of_changeset *ocs,
1019                                     struct device_node *np,
1020                                     const char *prop_name,
1021                                     const u32 *array, size_t sz)
1022 {
1023         struct property prop;
1024         __be32 *val;
1025         int i, ret;
1026
1027         val = kcalloc(sz, sizeof(__be32), GFP_KERNEL);
1028         if (!val)
1029                 return -ENOMEM;
1030
1031         for (i = 0; i < sz; i++)
1032                 val[i] = cpu_to_be32(array[i]);
1033         prop.name = (char *)prop_name;
1034         prop.length = sizeof(u32) * sz;
1035         prop.value = (void *)val;
1036
1037         ret = of_changeset_add_prop_helper(ocs, np, &prop);
1038         kfree(val);
1039
1040         return ret;
1041 }
1042 EXPORT_SYMBOL_GPL(of_changeset_add_prop_u32_array);