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