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