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