1 // SPDX-License-Identifier: GPL-2.0
3 * Support for dynamic device trees.
5 * On some platforms, the device tree can be manipulated at runtime.
6 * The routines in this section support adding, removing and changing
10 #define pr_fmt(fmt) "OF: " fmt
13 #include <linux/spinlock.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16 #include <linux/proc_fs.h>
18 #include "of_private.h"
20 static struct device_node *kobj_to_device_node(struct kobject *kobj)
22 return container_of(kobj, struct device_node, kobj);
26 * of_node_get() - Increment refcount of a node
27 * @node: Node to inc refcount, NULL is supported to simplify writing of
30 * Return: The node with refcount incremented.
32 struct device_node *of_node_get(struct device_node *node)
35 kobject_get(&node->kobj);
38 EXPORT_SYMBOL(of_node_get);
41 * of_node_put() - Decrement refcount of a node
42 * @node: Node to dec refcount, NULL is supported to simplify writing of
45 void of_node_put(struct device_node *node)
48 kobject_put(&node->kobj);
50 EXPORT_SYMBOL(of_node_put);
52 static BLOCKING_NOTIFIER_HEAD(of_reconfig_chain);
54 int of_reconfig_notifier_register(struct notifier_block *nb)
56 return blocking_notifier_chain_register(&of_reconfig_chain, nb);
58 EXPORT_SYMBOL_GPL(of_reconfig_notifier_register);
60 int of_reconfig_notifier_unregister(struct notifier_block *nb)
62 return blocking_notifier_chain_unregister(&of_reconfig_chain, nb);
64 EXPORT_SYMBOL_GPL(of_reconfig_notifier_unregister);
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",
76 int of_reconfig_notify(unsigned long action, struct of_reconfig_data *p)
80 struct of_reconfig_data *pr = p;
83 case OF_RECONFIG_ATTACH_NODE:
84 case OF_RECONFIG_DETACH_NODE:
85 pr_debug("notify %-15s %pOF\n", action_names[action],
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);
97 rc = blocking_notifier_call_chain(&of_reconfig_chain, action, p);
98 return notifier_to_errno(rc);
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
106 * Returns the new state of a device based on the notifier used.
108 * Return: 0 on device going from enabled to disabled, 1 on device
109 * going from disabled to enabled and -1 on no change.
111 int of_reconfig_get_state_change(unsigned long action, struct of_reconfig_data *pr)
113 struct property *prop, *old_prop = NULL;
114 int is_status, status_state, old_status_state, prev_state, new_state;
116 /* figure out if a device should be created or destroyed */
118 case OF_RECONFIG_ATTACH_NODE:
119 case OF_RECONFIG_DETACH_NODE:
120 prop = of_find_property(pr->dn, "status", NULL);
122 case OF_RECONFIG_ADD_PROPERTY:
123 case OF_RECONFIG_REMOVE_PROPERTY:
126 case OF_RECONFIG_UPDATE_PROPERTY:
128 old_prop = pr->old_prop;
131 return OF_RECONFIG_NO_CHANGE;
136 old_status_state = -1;
140 if (prop && !strcmp(prop->name, "status")) {
142 status_state = !strcmp(prop->value, "okay") ||
143 !strcmp(prop->value, "ok");
145 old_status_state = !strcmp(old_prop->value, "okay") ||
146 !strcmp(old_prop->value, "ok");
150 case OF_RECONFIG_ATTACH_NODE:
152 /* -1 & 0 status either missing or okay */
153 new_state = status_state != 0;
155 case OF_RECONFIG_DETACH_NODE:
156 /* -1 & 0 status either missing or okay */
157 prev_state = status_state != 0;
160 case OF_RECONFIG_ADD_PROPERTY:
162 /* no status property -> enabled (legacy) */
164 new_state = status_state;
167 case OF_RECONFIG_REMOVE_PROPERTY:
169 prev_state = status_state;
170 /* no status property -> enabled (legacy) */
174 case OF_RECONFIG_UPDATE_PROPERTY:
176 prev_state = old_status_state != 0;
177 new_state = status_state != 0;
182 if (prev_state == new_state)
183 return OF_RECONFIG_NO_CHANGE;
185 return new_state ? OF_RECONFIG_CHANGE_ADD : OF_RECONFIG_CHANGE_REMOVE;
187 EXPORT_SYMBOL_GPL(of_reconfig_get_state_change);
189 int of_property_notify(int action, struct device_node *np,
190 struct property *prop, struct property *oldprop)
192 struct of_reconfig_data pr;
194 /* only call notifiers if the node is attached */
195 if (!of_node_is_attached(np))
200 pr.old_prop = oldprop;
201 return of_reconfig_notify(action, &pr);
204 static void __of_attach_node(struct device_node *np)
206 const __be32 *phandle;
209 if (!of_node_check_flag(np, OF_OVERLAY)) {
210 np->name = __of_get_property(np, "name", NULL);
214 phandle = __of_get_property(np, "phandle", &sz);
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);
226 np->sibling = np->parent->child;
227 np->parent->child = np;
228 of_node_clear_flag(np, OF_DETACHED);
229 np->fwnode.flags |= FWNODE_FLAG_NOT_DEVICE;
233 * of_attach_node() - Plug a device node into the tree and global list.
234 * @np: Pointer to the caller's Device Node
236 int of_attach_node(struct device_node *np)
238 struct of_reconfig_data rd;
241 memset(&rd, 0, sizeof(rd));
244 mutex_lock(&of_mutex);
245 raw_spin_lock_irqsave(&devtree_lock, flags);
246 __of_attach_node(np);
247 raw_spin_unlock_irqrestore(&devtree_lock, flags);
249 __of_attach_node_sysfs(np);
250 mutex_unlock(&of_mutex);
252 of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, &rd);
257 void __of_detach_node(struct device_node *np)
259 struct device_node *parent;
261 if (WARN_ON(of_node_check_flag(np, OF_DETACHED)))
265 if (WARN_ON(!parent))
268 if (parent->child == np)
269 parent->child = np->sibling;
271 struct device_node *prevsib;
272 for (prevsib = np->parent->child;
273 prevsib->sibling != np;
274 prevsib = prevsib->sibling)
276 prevsib->sibling = np->sibling;
279 of_node_set_flag(np, OF_DETACHED);
281 /* race with of_find_node_by_phandle() prevented by devtree_lock */
282 __of_phandle_cache_inv_entry(np->phandle);
286 * of_detach_node() - "Unplug" a node from the device tree.
287 * @np: Pointer to the caller's Device Node
289 int of_detach_node(struct device_node *np)
291 struct of_reconfig_data rd;
294 memset(&rd, 0, sizeof(rd));
297 mutex_lock(&of_mutex);
298 raw_spin_lock_irqsave(&devtree_lock, flags);
299 __of_detach_node(np);
300 raw_spin_unlock_irqrestore(&devtree_lock, flags);
302 __of_detach_node_sysfs(np);
303 mutex_unlock(&of_mutex);
305 of_reconfig_notify(OF_RECONFIG_DETACH_NODE, &rd);
309 EXPORT_SYMBOL_GPL(of_detach_node);
311 static void property_list_free(struct property *prop_list)
313 struct property *prop, *next;
315 for (prop = prop_list; prop != NULL; prop = next) {
324 * of_node_release() - release a dynamically allocated node
325 * @kobj: kernel object of the node to be released
327 * In of_node_put() this function is passed to kref_put() as the destructor.
329 void of_node_release(struct kobject *kobj)
331 struct device_node *node = kobj_to_device_node(kobj);
334 * can not use '"%pOF", node' in pr_err() calls from this function
335 * because an of_node_get(node) when refcount is already zero
336 * will result in an error and a stack dump
339 /* We should never be releasing nodes that haven't been detached. */
340 if (!of_node_check_flag(node, OF_DETACHED)) {
342 pr_err("ERROR: %s() detected bad of_node_put() on %pOF/%s\n",
343 __func__, node->parent, node->full_name);
346 * of unittests will test this path. Do not print the stack
347 * trace when the error is caused by unittest so that we do
348 * not display what a normal developer might reasonably
349 * consider a real bug.
351 if (!IS_ENABLED(CONFIG_OF_UNITTEST) ||
352 strcmp(node->parent->full_name, "testcase-data")) {
354 pr_err("ERROR: next of_node_put() on this node will result in a kobject warning 'refcount_t: underflow; use-after-free.'\n");
359 if (!of_node_check_flag(node, OF_DYNAMIC))
362 if (of_node_check_flag(node, OF_OVERLAY)) {
364 if (!of_node_check_flag(node, OF_OVERLAY_FREE_CSET)) {
365 /* premature refcount of zero, do not free memory */
366 pr_err("ERROR: memory leak before free overlay changeset, %pOF\n",
372 * If node->properties non-empty then properties were added
373 * to this node either by different overlay that has not
374 * yet been removed, or by a non-overlay mechanism.
376 if (node->properties)
377 pr_err("ERROR: %s(), unexpected properties in %pOF\n",
382 pr_err("ERROR: %s() unexpected children for %pOF/%s\n",
383 __func__, node->parent, node->full_name);
385 property_list_free(node->properties);
386 property_list_free(node->deadprops);
387 fwnode_links_purge(of_fwnode_handle(node));
389 kfree(node->full_name);
395 * __of_prop_dup - Copy a property dynamically.
396 * @prop: Property to copy
397 * @allocflags: Allocation flags (typically pass GFP_KERNEL)
399 * Copy a property by dynamically allocating the memory of both the
400 * property structure and the property name & contents. The property's
401 * flags have the OF_DYNAMIC bit set so that we can differentiate between
402 * dynamically allocated properties and not.
404 * Return: The newly allocated property or NULL on out of memory error.
406 struct property *__of_prop_dup(const struct property *prop, gfp_t allocflags)
408 struct property *new;
410 new = kzalloc(sizeof(*new), allocflags);
415 * NOTE: There is no check for zero length value.
416 * In case of a boolean property, this will allocate a value
417 * of zero bytes. We do this to work around the use
418 * of of_get_property() calls on boolean values.
420 new->name = kstrdup(prop->name, allocflags);
421 new->value = kmemdup(prop->value, prop->length, allocflags);
422 new->length = prop->length;
423 if (!new->name || !new->value)
426 /* mark the property as dynamic */
427 of_property_set_flag(new, OF_DYNAMIC);
439 * __of_node_dup() - Duplicate or create an empty device node dynamically.
440 * @np: if not NULL, contains properties to be duplicated in new node
441 * @full_name: string value to be duplicated into new node's full_name field
443 * Create a device tree node, optionally duplicating the properties of
444 * another node. The node data are dynamically allocated and all the node
445 * flags have the OF_DYNAMIC & OF_DETACHED bits set.
447 * Return: The newly allocated node or NULL on out of memory error. Use
448 * of_node_put() on it when done to free the memory allocated for it.
450 struct device_node *__of_node_dup(const struct device_node *np,
451 const char *full_name)
453 struct device_node *node;
455 node = kzalloc(sizeof(*node), GFP_KERNEL);
458 node->full_name = kstrdup(full_name, GFP_KERNEL);
459 if (!node->full_name) {
464 of_node_set_flag(node, OF_DYNAMIC);
465 of_node_set_flag(node, OF_DETACHED);
468 /* Iterate over and duplicate all properties */
470 struct property *pp, *new_pp;
471 for_each_property_of_node(np, pp) {
472 new_pp = __of_prop_dup(pp, GFP_KERNEL);
475 if (__of_add_property(node, new_pp)) {
477 kfree(new_pp->value);
486 of_node_put(node); /* Frees the node and properties */
490 static void __of_changeset_entry_destroy(struct of_changeset_entry *ce)
492 if (ce->action == OF_RECONFIG_ATTACH_NODE &&
493 of_node_check_flag(ce->np, OF_OVERLAY)) {
494 if (kref_read(&ce->np->kobj.kref) > 1) {
495 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",
496 kref_read(&ce->np->kobj.kref), ce->np);
498 of_node_set_flag(ce->np, OF_OVERLAY_FREE_CSET);
508 static void __of_changeset_entry_dump(struct of_changeset_entry *ce)
510 switch (ce->action) {
511 case OF_RECONFIG_ADD_PROPERTY:
512 case OF_RECONFIG_REMOVE_PROPERTY:
513 case OF_RECONFIG_UPDATE_PROPERTY:
514 pr_debug("cset<%p> %-15s %pOF/%s\n", ce, action_names[ce->action],
515 ce->np, ce->prop->name);
517 case OF_RECONFIG_ATTACH_NODE:
518 case OF_RECONFIG_DETACH_NODE:
519 pr_debug("cset<%p> %-15s %pOF\n", ce, action_names[ce->action],
525 static inline void __of_changeset_entry_dump(struct of_changeset_entry *ce)
531 static void __of_changeset_entry_invert(struct of_changeset_entry *ce,
532 struct of_changeset_entry *rce)
534 memcpy(rce, ce, sizeof(*rce));
536 switch (ce->action) {
537 case OF_RECONFIG_ATTACH_NODE:
538 rce->action = OF_RECONFIG_DETACH_NODE;
540 case OF_RECONFIG_DETACH_NODE:
541 rce->action = OF_RECONFIG_ATTACH_NODE;
543 case OF_RECONFIG_ADD_PROPERTY:
544 rce->action = OF_RECONFIG_REMOVE_PROPERTY;
546 case OF_RECONFIG_REMOVE_PROPERTY:
547 rce->action = OF_RECONFIG_ADD_PROPERTY;
549 case OF_RECONFIG_UPDATE_PROPERTY:
550 rce->old_prop = ce->prop;
551 rce->prop = ce->old_prop;
552 /* update was used but original property did not exist */
554 rce->action = OF_RECONFIG_REMOVE_PROPERTY;
555 rce->prop = ce->prop;
561 static int __of_changeset_entry_notify(struct of_changeset_entry *ce,
564 struct of_reconfig_data rd;
565 struct of_changeset_entry ce_inverted;
569 __of_changeset_entry_invert(ce, &ce_inverted);
573 switch (ce->action) {
574 case OF_RECONFIG_ATTACH_NODE:
575 case OF_RECONFIG_DETACH_NODE:
576 memset(&rd, 0, sizeof(rd));
578 ret = of_reconfig_notify(ce->action, &rd);
580 case OF_RECONFIG_ADD_PROPERTY:
581 case OF_RECONFIG_REMOVE_PROPERTY:
582 case OF_RECONFIG_UPDATE_PROPERTY:
583 ret = of_property_notify(ce->action, ce->np, ce->prop, ce->old_prop);
586 pr_err("invalid devicetree changeset action: %i\n",
592 pr_err("changeset notifier error @%pOF\n", ce->np);
596 static int __of_changeset_entry_apply(struct of_changeset_entry *ce)
598 struct property *old_prop, **propp;
602 __of_changeset_entry_dump(ce);
604 raw_spin_lock_irqsave(&devtree_lock, flags);
605 switch (ce->action) {
606 case OF_RECONFIG_ATTACH_NODE:
607 __of_attach_node(ce->np);
609 case OF_RECONFIG_DETACH_NODE:
610 __of_detach_node(ce->np);
612 case OF_RECONFIG_ADD_PROPERTY:
613 /* If the property is in deadprops then it must be removed */
614 for (propp = &ce->np->deadprops; *propp; propp = &(*propp)->next) {
615 if (*propp == ce->prop) {
616 *propp = ce->prop->next;
617 ce->prop->next = NULL;
622 ret = __of_add_property(ce->np, ce->prop);
624 pr_err("changeset: add_property failed @%pOF/%s\n",
630 case OF_RECONFIG_REMOVE_PROPERTY:
631 ret = __of_remove_property(ce->np, ce->prop);
633 pr_err("changeset: remove_property failed @%pOF/%s\n",
640 case OF_RECONFIG_UPDATE_PROPERTY:
641 /* If the property is in deadprops then it must be removed */
642 for (propp = &ce->np->deadprops; *propp; propp = &(*propp)->next) {
643 if (*propp == ce->prop) {
644 *propp = ce->prop->next;
645 ce->prop->next = NULL;
650 ret = __of_update_property(ce->np, ce->prop, &old_prop);
652 pr_err("changeset: update_property failed @%pOF/%s\n",
661 raw_spin_unlock_irqrestore(&devtree_lock, flags);
666 switch (ce->action) {
667 case OF_RECONFIG_ATTACH_NODE:
668 __of_attach_node_sysfs(ce->np);
670 case OF_RECONFIG_DETACH_NODE:
671 __of_detach_node_sysfs(ce->np);
673 case OF_RECONFIG_ADD_PROPERTY:
674 /* ignore duplicate names */
675 __of_add_property_sysfs(ce->np, ce->prop);
677 case OF_RECONFIG_REMOVE_PROPERTY:
678 __of_remove_property_sysfs(ce->np, ce->prop);
680 case OF_RECONFIG_UPDATE_PROPERTY:
681 __of_update_property_sysfs(ce->np, ce->prop, ce->old_prop);
688 static inline int __of_changeset_entry_revert(struct of_changeset_entry *ce)
690 struct of_changeset_entry ce_inverted;
692 __of_changeset_entry_invert(ce, &ce_inverted);
693 return __of_changeset_entry_apply(&ce_inverted);
697 * of_changeset_init - Initialize a changeset for use
699 * @ocs: changeset pointer
701 * Initialize a changeset structure
703 void of_changeset_init(struct of_changeset *ocs)
705 memset(ocs, 0, sizeof(*ocs));
706 INIT_LIST_HEAD(&ocs->entries);
708 EXPORT_SYMBOL_GPL(of_changeset_init);
711 * of_changeset_destroy - Destroy a changeset
713 * @ocs: changeset pointer
715 * Destroys a changeset. Note that if a changeset is applied,
716 * its changes to the tree cannot be reverted.
718 void of_changeset_destroy(struct of_changeset *ocs)
720 struct of_changeset_entry *ce, *cen;
722 list_for_each_entry_safe_reverse(ce, cen, &ocs->entries, node)
723 __of_changeset_entry_destroy(ce);
725 EXPORT_SYMBOL_GPL(of_changeset_destroy);
728 * Apply the changeset entries in @ocs.
729 * If apply fails, an attempt is made to revert the entries that were
730 * successfully applied.
732 * If multiple revert errors occur then only the final revert error is reported.
734 * Returns 0 on success, a negative error value in case of an error.
735 * If a revert error occurs, it is returned in *ret_revert.
737 int __of_changeset_apply_entries(struct of_changeset *ocs, int *ret_revert)
739 struct of_changeset_entry *ce;
742 pr_debug("changeset: applying...\n");
743 list_for_each_entry(ce, &ocs->entries, node) {
744 ret = __of_changeset_entry_apply(ce);
746 pr_err("Error applying changeset (%d)\n", ret);
747 list_for_each_entry_continue_reverse(ce, &ocs->entries,
749 ret_tmp = __of_changeset_entry_revert(ce);
751 *ret_revert = ret_tmp;
761 * Returns 0 on success, a negative error value in case of an error.
763 * If multiple changeset entry notification errors occur then only the
764 * final notification error is reported.
766 int __of_changeset_apply_notify(struct of_changeset *ocs)
768 struct of_changeset_entry *ce;
769 int ret = 0, ret_tmp;
771 pr_debug("changeset: emitting notifiers.\n");
773 /* drop the global lock while emitting notifiers */
774 mutex_unlock(&of_mutex);
775 list_for_each_entry(ce, &ocs->entries, node) {
776 ret_tmp = __of_changeset_entry_notify(ce, 0);
780 mutex_lock(&of_mutex);
781 pr_debug("changeset: notifiers sent.\n");
787 * Returns 0 on success, a negative error value in case of an error.
789 * If a changeset entry apply fails, an attempt is made to revert any
790 * previous entries in the changeset. If any of the reverts fails,
791 * that failure is not reported. Thus the state of the device tree
792 * is unknown if an apply error occurs.
794 static int __of_changeset_apply(struct of_changeset *ocs)
796 int ret, ret_revert = 0;
798 ret = __of_changeset_apply_entries(ocs, &ret_revert);
800 ret = __of_changeset_apply_notify(ocs);
806 * of_changeset_apply - Applies a changeset
808 * @ocs: changeset pointer
810 * Applies a changeset to the live tree.
811 * Any side-effects of live tree state changes are applied here on
812 * success, like creation/destruction of devices and side-effects
813 * like creation of sysfs properties and directories.
815 * Return: 0 on success, a negative error value in case of an error.
816 * On error the partially applied effects are reverted.
818 int of_changeset_apply(struct of_changeset *ocs)
822 mutex_lock(&of_mutex);
823 ret = __of_changeset_apply(ocs);
824 mutex_unlock(&of_mutex);
828 EXPORT_SYMBOL_GPL(of_changeset_apply);
831 * Revert the changeset entries in @ocs.
832 * If revert fails, an attempt is made to re-apply the entries that were
833 * successfully removed.
835 * If multiple re-apply errors occur then only the final apply error is
838 * Returns 0 on success, a negative error value in case of an error.
839 * If an apply error occurs, it is returned in *ret_apply.
841 int __of_changeset_revert_entries(struct of_changeset *ocs, int *ret_apply)
843 struct of_changeset_entry *ce;
846 pr_debug("changeset: reverting...\n");
847 list_for_each_entry_reverse(ce, &ocs->entries, node) {
848 ret = __of_changeset_entry_revert(ce);
850 pr_err("Error reverting changeset (%d)\n", ret);
851 list_for_each_entry_continue(ce, &ocs->entries, node) {
852 ret_tmp = __of_changeset_entry_apply(ce);
854 *ret_apply = ret_tmp;
864 * If multiple changeset entry notification errors occur then only the
865 * final notification error is reported.
867 int __of_changeset_revert_notify(struct of_changeset *ocs)
869 struct of_changeset_entry *ce;
870 int ret = 0, ret_tmp;
872 pr_debug("changeset: emitting notifiers.\n");
874 /* drop the global lock while emitting notifiers */
875 mutex_unlock(&of_mutex);
876 list_for_each_entry_reverse(ce, &ocs->entries, node) {
877 ret_tmp = __of_changeset_entry_notify(ce, 1);
881 mutex_lock(&of_mutex);
882 pr_debug("changeset: notifiers sent.\n");
887 static int __of_changeset_revert(struct of_changeset *ocs)
892 ret = __of_changeset_revert_entries(ocs, &ret_reply);
895 ret = __of_changeset_revert_notify(ocs);
901 * of_changeset_revert - Reverts an applied changeset
903 * @ocs: changeset pointer
905 * Reverts a changeset returning the state of the tree to what it
906 * was before the application.
907 * Any side-effects like creation/destruction of devices and
908 * removal of sysfs properties and directories are applied.
910 * Return: 0 on success, a negative error value in case of an error.
912 int of_changeset_revert(struct of_changeset *ocs)
916 mutex_lock(&of_mutex);
917 ret = __of_changeset_revert(ocs);
918 mutex_unlock(&of_mutex);
922 EXPORT_SYMBOL_GPL(of_changeset_revert);
925 * of_changeset_action - Add an action to the tail of the changeset list
927 * @ocs: changeset pointer
928 * @action: action to perform
929 * @np: Pointer to device node
930 * @prop: Pointer to property
932 * On action being one of:
933 * + OF_RECONFIG_ATTACH_NODE
934 * + OF_RECONFIG_DETACH_NODE,
935 * + OF_RECONFIG_ADD_PROPERTY
936 * + OF_RECONFIG_REMOVE_PROPERTY,
937 * + OF_RECONFIG_UPDATE_PROPERTY
939 * Return: 0 on success, a negative error value in case of an error.
941 int of_changeset_action(struct of_changeset *ocs, unsigned long action,
942 struct device_node *np, struct property *prop)
944 struct of_changeset_entry *ce;
946 ce = kzalloc(sizeof(*ce), GFP_KERNEL);
950 /* get a reference to the node */
952 ce->np = of_node_get(np);
955 if (action == OF_RECONFIG_UPDATE_PROPERTY && prop)
956 ce->old_prop = of_find_property(np, prop->name, NULL);
958 /* add it to the list */
959 list_add_tail(&ce->node, &ocs->entries);
962 EXPORT_SYMBOL_GPL(of_changeset_action);