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