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
);
66 static 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",
75 #define _do_print(func, prefix, action, node, prop, ...) ({ \
76 func("changeset: " prefix "%-15s %pOF%s%s\n", \
77 ##__VA_ARGS__, action_names[action], node, \
78 prop ? ":" : "", prop ? prop->name : ""); \
80 #define of_changeset_action_err(...) _do_print(pr_err, __VA_ARGS__)
81 #define of_changeset_action_debug(...) _do_print(pr_debug, __VA_ARGS__)
83 int of_reconfig_notify(unsigned long action
, struct of_reconfig_data
*p
)
86 struct of_reconfig_data
*pr
= p
;
88 of_changeset_action_debug("notify: ", action
, pr
->dn
, pr
->prop
);
90 rc
= blocking_notifier_call_chain(&of_reconfig_chain
, action
, p
);
91 return notifier_to_errno(rc
);
95 * of_reconfig_get_state_change() - Returns new state of device
96 * @action - action of the of notifier
97 * @arg - argument of the of notifier
99 * Returns the new state of a device based on the notifier used.
101 * Return: 0 on device going from enabled to disabled, 1 on device
102 * going from disabled to enabled and -1 on no change.
104 int of_reconfig_get_state_change(unsigned long action
, struct of_reconfig_data
*pr
)
106 struct property
*prop
, *old_prop
= NULL
;
107 int is_status
, status_state
, old_status_state
, prev_state
, new_state
;
109 /* figure out if a device should be created or destroyed */
111 case OF_RECONFIG_ATTACH_NODE
:
112 case OF_RECONFIG_DETACH_NODE
:
113 prop
= of_find_property(pr
->dn
, "status", NULL
);
115 case OF_RECONFIG_ADD_PROPERTY
:
116 case OF_RECONFIG_REMOVE_PROPERTY
:
119 case OF_RECONFIG_UPDATE_PROPERTY
:
121 old_prop
= pr
->old_prop
;
124 return OF_RECONFIG_NO_CHANGE
;
129 old_status_state
= -1;
133 if (prop
&& !strcmp(prop
->name
, "status")) {
135 status_state
= !strcmp(prop
->value
, "okay") ||
136 !strcmp(prop
->value
, "ok");
138 old_status_state
= !strcmp(old_prop
->value
, "okay") ||
139 !strcmp(old_prop
->value
, "ok");
143 case OF_RECONFIG_ATTACH_NODE
:
145 /* -1 & 0 status either missing or okay */
146 new_state
= status_state
!= 0;
148 case OF_RECONFIG_DETACH_NODE
:
149 /* -1 & 0 status either missing or okay */
150 prev_state
= status_state
!= 0;
153 case OF_RECONFIG_ADD_PROPERTY
:
155 /* no status property -> enabled (legacy) */
157 new_state
= status_state
;
160 case OF_RECONFIG_REMOVE_PROPERTY
:
162 prev_state
= status_state
;
163 /* no status property -> enabled (legacy) */
167 case OF_RECONFIG_UPDATE_PROPERTY
:
169 prev_state
= old_status_state
!= 0;
170 new_state
= status_state
!= 0;
175 if (prev_state
== new_state
)
176 return OF_RECONFIG_NO_CHANGE
;
178 return new_state
? OF_RECONFIG_CHANGE_ADD
: OF_RECONFIG_CHANGE_REMOVE
;
180 EXPORT_SYMBOL_GPL(of_reconfig_get_state_change
);
182 int of_property_notify(int action
, struct device_node
*np
,
183 struct property
*prop
, struct property
*oldprop
)
185 struct of_reconfig_data pr
;
187 /* only call notifiers if the node is attached */
188 if (!of_node_is_attached(np
))
193 pr
.old_prop
= oldprop
;
194 return of_reconfig_notify(action
, &pr
);
197 static void __of_attach_node(struct device_node
*np
)
199 const __be32
*phandle
;
203 raw_spin_lock_irqsave(&devtree_lock
, flags
);
205 if (!of_node_check_flag(np
, OF_OVERLAY
)) {
206 np
->name
= __of_get_property(np
, "name", NULL
);
210 phandle
= __of_get_property(np
, "phandle", &sz
);
212 phandle
= __of_get_property(np
, "linux,phandle", &sz
);
213 if (IS_ENABLED(CONFIG_PPC_PSERIES
) && !phandle
)
214 phandle
= __of_get_property(np
, "ibm,phandle", &sz
);
215 if (phandle
&& (sz
>= 4))
216 np
->phandle
= be32_to_cpup(phandle
);
222 np
->sibling
= np
->parent
->child
;
223 np
->parent
->child
= np
;
224 of_node_clear_flag(np
, OF_DETACHED
);
225 np
->fwnode
.flags
|= FWNODE_FLAG_NOT_DEVICE
;
227 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
229 __of_attach_node_sysfs(np
);
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
;
240 memset(&rd
, 0, sizeof(rd
));
243 mutex_lock(&of_mutex
);
244 __of_attach_node(np
);
245 mutex_unlock(&of_mutex
);
247 of_reconfig_notify(OF_RECONFIG_ATTACH_NODE
, &rd
);
252 void __of_detach_node(struct device_node
*np
)
254 struct device_node
*parent
;
257 raw_spin_lock_irqsave(&devtree_lock
, flags
);
260 if (WARN_ON(of_node_check_flag(np
, OF_DETACHED
) || !parent
)) {
261 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
265 if (parent
->child
== np
)
266 parent
->child
= np
->sibling
;
268 struct device_node
*prevsib
;
269 for (prevsib
= np
->parent
->child
;
270 prevsib
->sibling
!= np
;
271 prevsib
= prevsib
->sibling
)
273 prevsib
->sibling
= np
->sibling
;
276 of_node_set_flag(np
, OF_DETACHED
);
278 /* race with of_find_node_by_phandle() prevented by devtree_lock */
279 __of_phandle_cache_inv_entry(np
->phandle
);
281 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
283 __of_detach_node_sysfs(np
);
287 * of_detach_node() - "Unplug" a node from the device tree.
288 * @np: Pointer to the caller's Device Node
290 int of_detach_node(struct device_node
*np
)
292 struct of_reconfig_data rd
;
294 memset(&rd
, 0, sizeof(rd
));
297 mutex_lock(&of_mutex
);
298 __of_detach_node(np
);
299 mutex_unlock(&of_mutex
);
301 of_reconfig_notify(OF_RECONFIG_DETACH_NODE
, &rd
);
305 EXPORT_SYMBOL_GPL(of_detach_node
);
307 static void property_list_free(struct property
*prop_list
)
309 struct property
*prop
, *next
;
311 for (prop
= prop_list
; prop
!= NULL
; prop
= next
) {
320 * of_node_release() - release a dynamically allocated node
321 * @kobj: kernel object of the node to be released
323 * In of_node_put() this function is passed to kref_put() as the destructor.
325 void of_node_release(struct kobject
*kobj
)
327 struct device_node
*node
= kobj_to_device_node(kobj
);
330 * can not use '"%pOF", node' in pr_err() calls from this function
331 * because an of_node_get(node) when refcount is already zero
332 * will result in an error and a stack dump
335 /* We should never be releasing nodes that haven't been detached. */
336 if (!of_node_check_flag(node
, OF_DETACHED
)) {
338 pr_err("ERROR: %s() detected bad of_node_put() on %pOF/%s\n",
339 __func__
, node
->parent
, node
->full_name
);
342 * of unittests will test this path. Do not print the stack
343 * trace when the error is caused by unittest so that we do
344 * not display what a normal developer might reasonably
345 * consider a real bug.
347 if (!IS_ENABLED(CONFIG_OF_UNITTEST
) ||
348 strcmp(node
->parent
->full_name
, "testcase-data")) {
350 pr_err("ERROR: next of_node_put() on this node will result in a kobject warning 'refcount_t: underflow; use-after-free.'\n");
355 if (!of_node_check_flag(node
, OF_DYNAMIC
))
358 if (of_node_check_flag(node
, OF_OVERLAY
)) {
360 if (!of_node_check_flag(node
, OF_OVERLAY_FREE_CSET
)) {
361 /* premature refcount of zero, do not free memory */
362 pr_err("ERROR: memory leak before free overlay changeset, %pOF\n",
368 * If node->properties non-empty then properties were added
369 * to this node either by different overlay that has not
370 * yet been removed, or by a non-overlay mechanism.
372 if (node
->properties
)
373 pr_err("ERROR: %s(), unexpected properties in %pOF\n",
378 pr_err("ERROR: %s() unexpected children for %pOF/%s\n",
379 __func__
, node
->parent
, node
->full_name
);
381 property_list_free(node
->properties
);
382 property_list_free(node
->deadprops
);
383 fwnode_links_purge(of_fwnode_handle(node
));
385 kfree(node
->full_name
);
391 * __of_prop_dup - Copy a property dynamically.
392 * @prop: Property to copy
393 * @allocflags: Allocation flags (typically pass GFP_KERNEL)
395 * Copy a property by dynamically allocating the memory of both the
396 * property structure and the property name & contents. The property's
397 * flags have the OF_DYNAMIC bit set so that we can differentiate between
398 * dynamically allocated properties and not.
400 * Return: The newly allocated property or NULL on out of memory error.
402 struct property
*__of_prop_dup(const struct property
*prop
, gfp_t allocflags
)
404 struct property
*new;
406 new = kzalloc(sizeof(*new), allocflags
);
411 * NOTE: There is no check for zero length value.
412 * In case of a boolean property, this will allocate a value
413 * of zero bytes. We do this to work around the use
414 * of of_get_property() calls on boolean values.
416 new->name
= kstrdup(prop
->name
, allocflags
);
417 new->value
= kmemdup(prop
->value
, prop
->length
, allocflags
);
418 new->length
= prop
->length
;
419 if (!new->name
|| !new->value
)
422 /* mark the property as dynamic */
423 of_property_set_flag(new, OF_DYNAMIC
);
435 * __of_node_dup() - Duplicate or create an empty device node dynamically.
436 * @np: if not NULL, contains properties to be duplicated in new node
437 * @full_name: string value to be duplicated into new node's full_name field
439 * Create a device tree node, optionally duplicating the properties of
440 * another node. The node data are dynamically allocated and all the node
441 * flags have the OF_DYNAMIC & OF_DETACHED bits set.
443 * Return: The newly allocated node or NULL on out of memory error. Use
444 * of_node_put() on it when done to free the memory allocated for it.
446 struct device_node
*__of_node_dup(const struct device_node
*np
,
447 const char *full_name
)
449 struct device_node
*node
;
451 node
= kzalloc(sizeof(*node
), GFP_KERNEL
);
454 node
->full_name
= kstrdup(full_name
, GFP_KERNEL
);
455 if (!node
->full_name
) {
460 of_node_set_flag(node
, OF_DYNAMIC
);
461 of_node_set_flag(node
, OF_DETACHED
);
464 /* Iterate over and duplicate all properties */
466 struct property
*pp
, *new_pp
;
467 for_each_property_of_node(np
, pp
) {
468 new_pp
= __of_prop_dup(pp
, GFP_KERNEL
);
471 if (__of_add_property(node
, new_pp
)) {
473 kfree(new_pp
->value
);
482 of_node_put(node
); /* Frees the node and properties */
487 * of_changeset_create_node - Dynamically create a device node and attach to
490 * @ocs: Pointer to changeset
491 * @parent: Pointer to parent device node
492 * @full_name: Node full name
494 * Return: Pointer to the created device node or NULL in case of an error.
496 struct device_node
*of_changeset_create_node(struct of_changeset
*ocs
,
497 struct device_node
*parent
,
498 const char *full_name
)
500 struct device_node
*np
;
503 np
= __of_node_dup(NULL
, full_name
);
508 ret
= of_changeset_attach_node(ocs
, np
);
516 EXPORT_SYMBOL(of_changeset_create_node
);
518 static void __of_changeset_entry_destroy(struct of_changeset_entry
*ce
)
520 if (ce
->action
== OF_RECONFIG_ATTACH_NODE
&&
521 of_node_check_flag(ce
->np
, OF_OVERLAY
)) {
522 if (kref_read(&ce
->np
->kobj
.kref
) > 1) {
523 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",
524 kref_read(&ce
->np
->kobj
.kref
), ce
->np
);
526 of_node_set_flag(ce
->np
, OF_OVERLAY_FREE_CSET
);
535 static void __of_changeset_entry_invert(struct of_changeset_entry
*ce
,
536 struct of_changeset_entry
*rce
)
538 memcpy(rce
, ce
, sizeof(*rce
));
540 switch (ce
->action
) {
541 case OF_RECONFIG_ATTACH_NODE
:
542 rce
->action
= OF_RECONFIG_DETACH_NODE
;
544 case OF_RECONFIG_DETACH_NODE
:
545 rce
->action
= OF_RECONFIG_ATTACH_NODE
;
547 case OF_RECONFIG_ADD_PROPERTY
:
548 rce
->action
= OF_RECONFIG_REMOVE_PROPERTY
;
550 case OF_RECONFIG_REMOVE_PROPERTY
:
551 rce
->action
= OF_RECONFIG_ADD_PROPERTY
;
553 case OF_RECONFIG_UPDATE_PROPERTY
:
554 rce
->old_prop
= ce
->prop
;
555 rce
->prop
= ce
->old_prop
;
556 /* update was used but original property did not exist */
558 rce
->action
= OF_RECONFIG_REMOVE_PROPERTY
;
559 rce
->prop
= ce
->prop
;
565 static int __of_changeset_entry_notify(struct of_changeset_entry
*ce
,
568 struct of_reconfig_data rd
;
569 struct of_changeset_entry ce_inverted
;
573 __of_changeset_entry_invert(ce
, &ce_inverted
);
577 switch (ce
->action
) {
578 case OF_RECONFIG_ATTACH_NODE
:
579 case OF_RECONFIG_DETACH_NODE
:
580 memset(&rd
, 0, sizeof(rd
));
582 ret
= of_reconfig_notify(ce
->action
, &rd
);
584 case OF_RECONFIG_ADD_PROPERTY
:
585 case OF_RECONFIG_REMOVE_PROPERTY
:
586 case OF_RECONFIG_UPDATE_PROPERTY
:
587 ret
= of_property_notify(ce
->action
, ce
->np
, ce
->prop
, ce
->old_prop
);
590 pr_err("invalid devicetree changeset action: %i\n",
596 pr_err("changeset notifier error @%pOF\n", ce
->np
);
600 static int __of_changeset_entry_apply(struct of_changeset_entry
*ce
)
604 of_changeset_action_debug("apply: ", ce
->action
, ce
->np
, ce
->prop
);
606 switch (ce
->action
) {
607 case OF_RECONFIG_ATTACH_NODE
:
608 __of_attach_node(ce
->np
);
610 case OF_RECONFIG_DETACH_NODE
:
611 __of_detach_node(ce
->np
);
613 case OF_RECONFIG_ADD_PROPERTY
:
614 ret
= __of_add_property(ce
->np
, ce
->prop
);
616 case OF_RECONFIG_REMOVE_PROPERTY
:
617 ret
= __of_remove_property(ce
->np
, ce
->prop
);
620 case OF_RECONFIG_UPDATE_PROPERTY
:
621 ret
= __of_update_property(ce
->np
, ce
->prop
, &ce
->old_prop
);
628 of_changeset_action_err("apply failed: ", ce
->action
, ce
->np
, ce
->prop
);
635 static inline int __of_changeset_entry_revert(struct of_changeset_entry
*ce
)
637 struct of_changeset_entry ce_inverted
;
639 __of_changeset_entry_invert(ce
, &ce_inverted
);
640 return __of_changeset_entry_apply(&ce_inverted
);
644 * of_changeset_init - Initialize a changeset for use
646 * @ocs: changeset pointer
648 * Initialize a changeset structure
650 void of_changeset_init(struct of_changeset
*ocs
)
652 memset(ocs
, 0, sizeof(*ocs
));
653 INIT_LIST_HEAD(&ocs
->entries
);
655 EXPORT_SYMBOL_GPL(of_changeset_init
);
658 * of_changeset_destroy - Destroy a changeset
660 * @ocs: changeset pointer
662 * Destroys a changeset. Note that if a changeset is applied,
663 * its changes to the tree cannot be reverted.
665 void of_changeset_destroy(struct of_changeset
*ocs
)
667 struct of_changeset_entry
*ce
, *cen
;
669 list_for_each_entry_safe_reverse(ce
, cen
, &ocs
->entries
, node
)
670 __of_changeset_entry_destroy(ce
);
672 EXPORT_SYMBOL_GPL(of_changeset_destroy
);
675 * Apply the changeset entries in @ocs.
676 * If apply fails, an attempt is made to revert the entries that were
677 * successfully applied.
679 * If multiple revert errors occur then only the final revert error is reported.
681 * Returns 0 on success, a negative error value in case of an error.
682 * If a revert error occurs, it is returned in *ret_revert.
684 int __of_changeset_apply_entries(struct of_changeset
*ocs
, int *ret_revert
)
686 struct of_changeset_entry
*ce
;
689 pr_debug("changeset: applying...\n");
690 list_for_each_entry(ce
, &ocs
->entries
, node
) {
691 ret
= __of_changeset_entry_apply(ce
);
693 pr_err("Error applying changeset (%d)\n", ret
);
694 list_for_each_entry_continue_reverse(ce
, &ocs
->entries
,
696 ret_tmp
= __of_changeset_entry_revert(ce
);
698 *ret_revert
= ret_tmp
;
708 * Returns 0 on success, a negative error value in case of an error.
710 * If multiple changeset entry notification errors occur then only the
711 * final notification error is reported.
713 int __of_changeset_apply_notify(struct of_changeset
*ocs
)
715 struct of_changeset_entry
*ce
;
716 int ret
= 0, ret_tmp
;
718 pr_debug("changeset: emitting notifiers.\n");
720 /* drop the global lock while emitting notifiers */
721 mutex_unlock(&of_mutex
);
722 list_for_each_entry(ce
, &ocs
->entries
, node
) {
723 ret_tmp
= __of_changeset_entry_notify(ce
, 0);
727 mutex_lock(&of_mutex
);
728 pr_debug("changeset: notifiers sent.\n");
734 * Returns 0 on success, a negative error value in case of an error.
736 * If a changeset entry apply fails, an attempt is made to revert any
737 * previous entries in the changeset. If any of the reverts fails,
738 * that failure is not reported. Thus the state of the device tree
739 * is unknown if an apply error occurs.
741 static int __of_changeset_apply(struct of_changeset
*ocs
)
743 int ret
, ret_revert
= 0;
745 ret
= __of_changeset_apply_entries(ocs
, &ret_revert
);
747 ret
= __of_changeset_apply_notify(ocs
);
753 * of_changeset_apply - Applies a changeset
755 * @ocs: changeset pointer
757 * Applies a changeset to the live tree.
758 * Any side-effects of live tree state changes are applied here on
759 * success, like creation/destruction of devices and side-effects
760 * like creation of sysfs properties and directories.
762 * Return: 0 on success, a negative error value in case of an error.
763 * On error the partially applied effects are reverted.
765 int of_changeset_apply(struct of_changeset
*ocs
)
769 mutex_lock(&of_mutex
);
770 ret
= __of_changeset_apply(ocs
);
771 mutex_unlock(&of_mutex
);
775 EXPORT_SYMBOL_GPL(of_changeset_apply
);
778 * Revert the changeset entries in @ocs.
779 * If revert fails, an attempt is made to re-apply the entries that were
780 * successfully removed.
782 * If multiple re-apply errors occur then only the final apply error is
785 * Returns 0 on success, a negative error value in case of an error.
786 * If an apply error occurs, it is returned in *ret_apply.
788 int __of_changeset_revert_entries(struct of_changeset
*ocs
, int *ret_apply
)
790 struct of_changeset_entry
*ce
;
793 pr_debug("changeset: reverting...\n");
794 list_for_each_entry_reverse(ce
, &ocs
->entries
, node
) {
795 ret
= __of_changeset_entry_revert(ce
);
797 pr_err("Error reverting changeset (%d)\n", ret
);
798 list_for_each_entry_continue(ce
, &ocs
->entries
, node
) {
799 ret_tmp
= __of_changeset_entry_apply(ce
);
801 *ret_apply
= ret_tmp
;
811 * If multiple changeset entry notification errors occur then only the
812 * final notification error is reported.
814 int __of_changeset_revert_notify(struct of_changeset
*ocs
)
816 struct of_changeset_entry
*ce
;
817 int ret
= 0, ret_tmp
;
819 pr_debug("changeset: emitting notifiers.\n");
821 /* drop the global lock while emitting notifiers */
822 mutex_unlock(&of_mutex
);
823 list_for_each_entry_reverse(ce
, &ocs
->entries
, node
) {
824 ret_tmp
= __of_changeset_entry_notify(ce
, 1);
828 mutex_lock(&of_mutex
);
829 pr_debug("changeset: notifiers sent.\n");
834 static int __of_changeset_revert(struct of_changeset
*ocs
)
839 ret
= __of_changeset_revert_entries(ocs
, &ret_reply
);
842 ret
= __of_changeset_revert_notify(ocs
);
848 * of_changeset_revert - Reverts an applied changeset
850 * @ocs: changeset pointer
852 * Reverts a changeset returning the state of the tree to what it
853 * was before the application.
854 * Any side-effects like creation/destruction of devices and
855 * removal of sysfs properties and directories are applied.
857 * Return: 0 on success, a negative error value in case of an error.
859 int of_changeset_revert(struct of_changeset
*ocs
)
863 mutex_lock(&of_mutex
);
864 ret
= __of_changeset_revert(ocs
);
865 mutex_unlock(&of_mutex
);
869 EXPORT_SYMBOL_GPL(of_changeset_revert
);
872 * of_changeset_action - Add an action to the tail of the changeset list
874 * @ocs: changeset pointer
875 * @action: action to perform
876 * @np: Pointer to device node
877 * @prop: Pointer to property
879 * On action being one of:
880 * + OF_RECONFIG_ATTACH_NODE
881 * + OF_RECONFIG_DETACH_NODE,
882 * + OF_RECONFIG_ADD_PROPERTY
883 * + OF_RECONFIG_REMOVE_PROPERTY,
884 * + OF_RECONFIG_UPDATE_PROPERTY
886 * Return: 0 on success, a negative error value in case of an error.
888 int of_changeset_action(struct of_changeset
*ocs
, unsigned long action
,
889 struct device_node
*np
, struct property
*prop
)
891 struct of_changeset_entry
*ce
;
893 ce
= kzalloc(sizeof(*ce
), GFP_KERNEL
);
897 if (WARN_ON(action
>= ARRAY_SIZE(action_names
)))
900 /* get a reference to the node */
902 ce
->np
= of_node_get(np
);
905 /* add it to the list */
906 list_add_tail(&ce
->node
, &ocs
->entries
);
909 EXPORT_SYMBOL_GPL(of_changeset_action
);
911 static int of_changeset_add_prop_helper(struct of_changeset
*ocs
,
912 struct device_node
*np
,
913 const struct property
*pp
)
915 struct property
*new_pp
;
918 new_pp
= __of_prop_dup(pp
, GFP_KERNEL
);
922 ret
= of_changeset_add_property(ocs
, np
, new_pp
);
925 kfree(new_pp
->value
);
933 * of_changeset_add_prop_string - Add a string property to a changeset
935 * @ocs: changeset pointer
936 * @np: device node pointer
937 * @prop_name: name of the property to be added
938 * @str: pointer to null terminated string
940 * Create a string property and add it to a changeset.
942 * Return: 0 on success, a negative error value in case of an error.
944 int of_changeset_add_prop_string(struct of_changeset
*ocs
,
945 struct device_node
*np
,
946 const char *prop_name
, const char *str
)
948 struct property prop
;
950 prop
.name
= (char *)prop_name
;
951 prop
.length
= strlen(str
) + 1;
952 prop
.value
= (void *)str
;
954 return of_changeset_add_prop_helper(ocs
, np
, &prop
);
956 EXPORT_SYMBOL_GPL(of_changeset_add_prop_string
);
959 * of_changeset_add_prop_string_array - Add a string list property to
962 * @ocs: changeset pointer
963 * @np: device node pointer
964 * @prop_name: name of the property to be added
965 * @str_array: pointer to an array of null terminated strings
966 * @sz: number of string array elements
968 * Create a string list property and add it to a changeset.
970 * Return: 0 on success, a negative error value in case of an error.
972 int of_changeset_add_prop_string_array(struct of_changeset
*ocs
,
973 struct device_node
*np
,
974 const char *prop_name
,
975 const char **str_array
, size_t sz
)
977 struct property prop
;
981 prop
.name
= (char *)prop_name
;
984 for (i
= 0; i
< sz
; i
++)
985 prop
.length
+= strlen(str_array
[i
]) + 1;
987 prop
.value
= kmalloc(prop
.length
, GFP_KERNEL
);
992 for (i
= 0; i
< sz
; i
++) {
993 vp
+= snprintf(vp
, (char *)prop
.value
+ prop
.length
- vp
, "%s",
996 ret
= of_changeset_add_prop_helper(ocs
, np
, &prop
);
1001 EXPORT_SYMBOL_GPL(of_changeset_add_prop_string_array
);
1004 * of_changeset_add_prop_u32_array - Add a property of 32 bit integers
1005 * property to a changeset
1007 * @ocs: changeset pointer
1008 * @np: device node pointer
1009 * @prop_name: name of the property to be added
1010 * @array: pointer to an array of 32 bit integers
1011 * @sz: number of array elements
1013 * Create a property of 32 bit integers and add it to a changeset.
1015 * Return: 0 on success, a negative error value in case of an error.
1017 int of_changeset_add_prop_u32_array(struct of_changeset
*ocs
,
1018 struct device_node
*np
,
1019 const char *prop_name
,
1020 const u32
*array
, size_t sz
)
1022 struct property prop
;
1026 val
= kcalloc(sz
, sizeof(__be32
), GFP_KERNEL
);
1030 for (i
= 0; i
< sz
; i
++)
1031 val
[i
] = cpu_to_be32(array
[i
]);
1032 prop
.name
= (char *)prop_name
;
1033 prop
.length
= sizeof(u32
) * sz
;
1034 prop
.value
= (void *)val
;
1036 ret
= of_changeset_add_prop_helper(ocs
, np
, &prop
);
1041 EXPORT_SYMBOL_GPL(of_changeset_add_prop_u32_array
);