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