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