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