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