drivers/of/dynamic.c

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