Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0+ */
2 : #ifndef _LINUX_OF_H
3 : #define _LINUX_OF_H
4 : /*
5 : * Definitions for talking to the Open Firmware PROM on
6 : * Power Macintosh and other computers.
7 : *
8 : * Copyright (C) 1996-2005 Paul Mackerras.
9 : *
10 : * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
11 : * Updates for SPARC64 by David S. Miller
12 : * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp.
13 : */
14 : #include <linux/types.h>
15 : #include <linux/bitops.h>
16 : #include <linux/errno.h>
17 : #include <linux/kobject.h>
18 : #include <linux/mod_devicetable.h>
19 : #include <linux/spinlock.h>
20 : #include <linux/topology.h>
21 : #include <linux/notifier.h>
22 : #include <linux/property.h>
23 : #include <linux/list.h>
24 :
25 : #include <asm/byteorder.h>
26 : #include <asm/errno.h>
27 :
28 : typedef u32 phandle;
29 : typedef u32 ihandle;
30 :
31 : struct property {
32 : char *name;
33 : int length;
34 : void *value;
35 : struct property *next;
36 : #if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
37 : unsigned long _flags;
38 : #endif
39 : #if defined(CONFIG_OF_PROMTREE)
40 : unsigned int unique_id;
41 : #endif
42 : #if defined(CONFIG_OF_KOBJ)
43 : struct bin_attribute attr;
44 : #endif
45 : };
46 :
47 : #if defined(CONFIG_SPARC)
48 : struct of_irq_controller;
49 : #endif
50 :
51 : struct device_node {
52 : const char *name;
53 : phandle phandle;
54 : const char *full_name;
55 : struct fwnode_handle fwnode;
56 :
57 : struct property *properties;
58 : struct property *deadprops; /* removed properties */
59 : struct device_node *parent;
60 : struct device_node *child;
61 : struct device_node *sibling;
62 : #if defined(CONFIG_OF_KOBJ)
63 : struct kobject kobj;
64 : #endif
65 : unsigned long _flags;
66 : void *data;
67 : #if defined(CONFIG_SPARC)
68 : unsigned int unique_id;
69 : struct of_irq_controller *irq_trans;
70 : #endif
71 : };
72 :
73 : #define MAX_PHANDLE_ARGS 16
74 : struct of_phandle_args {
75 : struct device_node *np;
76 : int args_count;
77 : uint32_t args[MAX_PHANDLE_ARGS];
78 : };
79 :
80 : struct of_phandle_iterator {
81 : /* Common iterator information */
82 : const char *cells_name;
83 : int cell_count;
84 : const struct device_node *parent;
85 :
86 : /* List size information */
87 : const __be32 *list_end;
88 : const __be32 *phandle_end;
89 :
90 : /* Current position state */
91 : const __be32 *cur;
92 : uint32_t cur_count;
93 : phandle phandle;
94 : struct device_node *node;
95 : };
96 :
97 : struct of_reconfig_data {
98 : struct device_node *dn;
99 : struct property *prop;
100 : struct property *old_prop;
101 : };
102 :
103 : /* initialize a node */
104 : extern struct kobj_type of_node_ktype;
105 : extern const struct fwnode_operations of_fwnode_ops;
106 : static inline void of_node_init(struct device_node *node)
107 : {
108 : #if defined(CONFIG_OF_KOBJ)
109 : kobject_init(&node->kobj, &of_node_ktype);
110 : #endif
111 : fwnode_init(&node->fwnode, &of_fwnode_ops);
112 : }
113 :
114 : #if defined(CONFIG_OF_KOBJ)
115 : #define of_node_kobj(n) (&(n)->kobj)
116 : #else
117 : #define of_node_kobj(n) NULL
118 : #endif
119 :
120 : #ifdef CONFIG_OF_DYNAMIC
121 : extern struct device_node *of_node_get(struct device_node *node);
122 : extern void of_node_put(struct device_node *node);
123 : #else /* CONFIG_OF_DYNAMIC */
124 : /* Dummy ref counting routines - to be implemented later */
125 3 : static inline struct device_node *of_node_get(struct device_node *node)
126 : {
127 3 : return node;
128 : }
129 0 : static inline void of_node_put(struct device_node *node) { }
130 : #endif /* !CONFIG_OF_DYNAMIC */
131 :
132 : /* Pointer for first entry in chain of all nodes. */
133 : extern struct device_node *of_root;
134 : extern struct device_node *of_chosen;
135 : extern struct device_node *of_aliases;
136 : extern struct device_node *of_stdout;
137 : extern raw_spinlock_t devtree_lock;
138 :
139 : /*
140 : * struct device_node flag descriptions
141 : * (need to be visible even when !CONFIG_OF)
142 : */
143 : #define OF_DYNAMIC 1 /* (and properties) allocated via kmalloc */
144 : #define OF_DETACHED 2 /* detached from the device tree */
145 : #define OF_POPULATED 3 /* device already created */
146 : #define OF_POPULATED_BUS 4 /* platform bus created for children */
147 : #define OF_OVERLAY 5 /* allocated for an overlay */
148 : #define OF_OVERLAY_FREE_CSET 6 /* in overlay cset being freed */
149 :
150 : #define OF_BAD_ADDR ((u64)-1)
151 :
152 : #ifdef CONFIG_OF
153 : void of_core_init(void);
154 :
155 : static inline bool is_of_node(const struct fwnode_handle *fwnode)
156 : {
157 : return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &of_fwnode_ops;
158 : }
159 :
160 : #define to_of_node(__fwnode) \
161 : ({ \
162 : typeof(__fwnode) __to_of_node_fwnode = (__fwnode); \
163 : \
164 : is_of_node(__to_of_node_fwnode) ? \
165 : container_of(__to_of_node_fwnode, \
166 : struct device_node, fwnode) : \
167 : NULL; \
168 : })
169 :
170 : #define of_fwnode_handle(node) \
171 : ({ \
172 : typeof(node) __of_fwnode_handle_node = (node); \
173 : \
174 : __of_fwnode_handle_node ? \
175 : &__of_fwnode_handle_node->fwnode : NULL; \
176 : })
177 :
178 : static inline bool of_have_populated_dt(void)
179 : {
180 : return of_root != NULL;
181 : }
182 :
183 : static inline bool of_node_is_root(const struct device_node *node)
184 : {
185 : return node && (node->parent == NULL);
186 : }
187 :
188 : static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
189 : {
190 : return test_bit(flag, &n->_flags);
191 : }
192 :
193 : static inline int of_node_test_and_set_flag(struct device_node *n,
194 : unsigned long flag)
195 : {
196 : return test_and_set_bit(flag, &n->_flags);
197 : }
198 :
199 : static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
200 : {
201 : set_bit(flag, &n->_flags);
202 : }
203 :
204 : static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
205 : {
206 : clear_bit(flag, &n->_flags);
207 : }
208 :
209 : #if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
210 : static inline int of_property_check_flag(struct property *p, unsigned long flag)
211 : {
212 : return test_bit(flag, &p->_flags);
213 : }
214 :
215 : static inline void of_property_set_flag(struct property *p, unsigned long flag)
216 : {
217 : set_bit(flag, &p->_flags);
218 : }
219 :
220 : static inline void of_property_clear_flag(struct property *p, unsigned long flag)
221 : {
222 : clear_bit(flag, &p->_flags);
223 : }
224 : #endif
225 :
226 : extern struct device_node *__of_find_all_nodes(struct device_node *prev);
227 : extern struct device_node *of_find_all_nodes(struct device_node *prev);
228 :
229 : /*
230 : * OF address retrieval & translation
231 : */
232 :
233 : /* Helper to read a big number; size is in cells (not bytes) */
234 : static inline u64 of_read_number(const __be32 *cell, int size)
235 : {
236 : u64 r = 0;
237 : for (; size--; cell++)
238 : r = (r << 32) | be32_to_cpu(*cell);
239 : return r;
240 : }
241 :
242 : /* Like of_read_number, but we want an unsigned long result */
243 : static inline unsigned long of_read_ulong(const __be32 *cell, int size)
244 : {
245 : /* toss away upper bits if unsigned long is smaller than u64 */
246 : return of_read_number(cell, size);
247 : }
248 :
249 : #if defined(CONFIG_SPARC)
250 : #include <asm/prom.h>
251 : #endif
252 :
253 : #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
254 : #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
255 :
256 : extern bool of_node_name_eq(const struct device_node *np, const char *name);
257 : extern bool of_node_name_prefix(const struct device_node *np, const char *prefix);
258 :
259 : static inline const char *of_node_full_name(const struct device_node *np)
260 : {
261 : return np ? np->full_name : "<no-node>";
262 : }
263 :
264 : #define for_each_of_allnodes_from(from, dn) \
265 : for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn))
266 : #define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn)
267 : extern struct device_node *of_find_node_by_name(struct device_node *from,
268 : const char *name);
269 : extern struct device_node *of_find_node_by_type(struct device_node *from,
270 : const char *type);
271 : extern struct device_node *of_find_compatible_node(struct device_node *from,
272 : const char *type, const char *compat);
273 : extern struct device_node *of_find_matching_node_and_match(
274 : struct device_node *from,
275 : const struct of_device_id *matches,
276 : const struct of_device_id **match);
277 :
278 : extern struct device_node *of_find_node_opts_by_path(const char *path,
279 : const char **opts);
280 : static inline struct device_node *of_find_node_by_path(const char *path)
281 : {
282 : return of_find_node_opts_by_path(path, NULL);
283 : }
284 :
285 : extern struct device_node *of_find_node_by_phandle(phandle handle);
286 : extern struct device_node *of_get_parent(const struct device_node *node);
287 : extern struct device_node *of_get_next_parent(struct device_node *node);
288 : extern struct device_node *of_get_next_child(const struct device_node *node,
289 : struct device_node *prev);
290 : extern struct device_node *of_get_next_available_child(
291 : const struct device_node *node, struct device_node *prev);
292 :
293 : extern struct device_node *of_get_compatible_child(const struct device_node *parent,
294 : const char *compatible);
295 : extern struct device_node *of_get_child_by_name(const struct device_node *node,
296 : const char *name);
297 :
298 : /* cache lookup */
299 : extern struct device_node *of_find_next_cache_node(const struct device_node *);
300 : extern int of_find_last_cache_level(unsigned int cpu);
301 : extern struct device_node *of_find_node_with_property(
302 : struct device_node *from, const char *prop_name);
303 :
304 : extern struct property *of_find_property(const struct device_node *np,
305 : const char *name,
306 : int *lenp);
307 : extern int of_property_count_elems_of_size(const struct device_node *np,
308 : const char *propname, int elem_size);
309 : extern int of_property_read_u32_index(const struct device_node *np,
310 : const char *propname,
311 : u32 index, u32 *out_value);
312 : extern int of_property_read_u64_index(const struct device_node *np,
313 : const char *propname,
314 : u32 index, u64 *out_value);
315 : extern int of_property_read_variable_u8_array(const struct device_node *np,
316 : const char *propname, u8 *out_values,
317 : size_t sz_min, size_t sz_max);
318 : extern int of_property_read_variable_u16_array(const struct device_node *np,
319 : const char *propname, u16 *out_values,
320 : size_t sz_min, size_t sz_max);
321 : extern int of_property_read_variable_u32_array(const struct device_node *np,
322 : const char *propname,
323 : u32 *out_values,
324 : size_t sz_min,
325 : size_t sz_max);
326 : extern int of_property_read_u64(const struct device_node *np,
327 : const char *propname, u64 *out_value);
328 : extern int of_property_read_variable_u64_array(const struct device_node *np,
329 : const char *propname,
330 : u64 *out_values,
331 : size_t sz_min,
332 : size_t sz_max);
333 :
334 : extern int of_property_read_string(const struct device_node *np,
335 : const char *propname,
336 : const char **out_string);
337 : extern int of_property_match_string(const struct device_node *np,
338 : const char *propname,
339 : const char *string);
340 : extern int of_property_read_string_helper(const struct device_node *np,
341 : const char *propname,
342 : const char **out_strs, size_t sz, int index);
343 : extern int of_device_is_compatible(const struct device_node *device,
344 : const char *);
345 : extern int of_device_compatible_match(struct device_node *device,
346 : const char *const *compat);
347 : extern bool of_device_is_available(const struct device_node *device);
348 : extern bool of_device_is_big_endian(const struct device_node *device);
349 : extern const void *of_get_property(const struct device_node *node,
350 : const char *name,
351 : int *lenp);
352 : extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
353 : extern struct device_node *of_get_next_cpu_node(struct device_node *prev);
354 : extern struct device_node *of_get_cpu_state_node(struct device_node *cpu_node,
355 : int index);
356 :
357 : #define for_each_property_of_node(dn, pp) \
358 : for (pp = dn->properties; pp != NULL; pp = pp->next)
359 :
360 : extern int of_n_addr_cells(struct device_node *np);
361 : extern int of_n_size_cells(struct device_node *np);
362 : extern const struct of_device_id *of_match_node(
363 : const struct of_device_id *matches, const struct device_node *node);
364 : extern int of_modalias_node(struct device_node *node, char *modalias, int len);
365 : extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
366 : extern struct device_node *of_parse_phandle(const struct device_node *np,
367 : const char *phandle_name,
368 : int index);
369 : extern int of_parse_phandle_with_args(const struct device_node *np,
370 : const char *list_name, const char *cells_name, int index,
371 : struct of_phandle_args *out_args);
372 : extern int of_parse_phandle_with_args_map(const struct device_node *np,
373 : const char *list_name, const char *stem_name, int index,
374 : struct of_phandle_args *out_args);
375 : extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
376 : const char *list_name, int cells_count, int index,
377 : struct of_phandle_args *out_args);
378 : extern int of_count_phandle_with_args(const struct device_node *np,
379 : const char *list_name, const char *cells_name);
380 :
381 : /* phandle iterator functions */
382 : extern int of_phandle_iterator_init(struct of_phandle_iterator *it,
383 : const struct device_node *np,
384 : const char *list_name,
385 : const char *cells_name,
386 : int cell_count);
387 :
388 : extern int of_phandle_iterator_next(struct of_phandle_iterator *it);
389 : extern int of_phandle_iterator_args(struct of_phandle_iterator *it,
390 : uint32_t *args,
391 : int size);
392 :
393 : extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
394 : extern int of_alias_get_id(struct device_node *np, const char *stem);
395 : extern int of_alias_get_highest_id(const char *stem);
396 : extern int of_alias_get_alias_list(const struct of_device_id *matches,
397 : const char *stem, unsigned long *bitmap,
398 : unsigned int nbits);
399 :
400 : extern int of_machine_is_compatible(const char *compat);
401 :
402 : extern int of_add_property(struct device_node *np, struct property *prop);
403 : extern int of_remove_property(struct device_node *np, struct property *prop);
404 : extern int of_update_property(struct device_node *np, struct property *newprop);
405 :
406 : /* For updating the device tree at runtime */
407 : #define OF_RECONFIG_ATTACH_NODE 0x0001
408 : #define OF_RECONFIG_DETACH_NODE 0x0002
409 : #define OF_RECONFIG_ADD_PROPERTY 0x0003
410 : #define OF_RECONFIG_REMOVE_PROPERTY 0x0004
411 : #define OF_RECONFIG_UPDATE_PROPERTY 0x0005
412 :
413 : extern int of_attach_node(struct device_node *);
414 : extern int of_detach_node(struct device_node *);
415 :
416 : #define of_match_ptr(_ptr) (_ptr)
417 :
418 : /**
419 : * of_property_read_u8_array - Find and read an array of u8 from a property.
420 : *
421 : * @np: device node from which the property value is to be read.
422 : * @propname: name of the property to be searched.
423 : * @out_values: pointer to return value, modified only if return value is 0.
424 : * @sz: number of array elements to read
425 : *
426 : * Search for a property in a device node and read 8-bit value(s) from
427 : * it. Returns 0 on success, -EINVAL if the property does not exist,
428 : * -ENODATA if property does not have a value, and -EOVERFLOW if the
429 : * property data isn't large enough.
430 : *
431 : * dts entry of array should be like:
432 : * property = /bits/ 8 <0x50 0x60 0x70>;
433 : *
434 : * The out_values is modified only if a valid u8 value can be decoded.
435 : */
436 : static inline int of_property_read_u8_array(const struct device_node *np,
437 : const char *propname,
438 : u8 *out_values, size_t sz)
439 : {
440 : int ret = of_property_read_variable_u8_array(np, propname, out_values,
441 : sz, 0);
442 : if (ret >= 0)
443 : return 0;
444 : else
445 : return ret;
446 : }
447 :
448 : /**
449 : * of_property_read_u16_array - Find and read an array of u16 from a property.
450 : *
451 : * @np: device node from which the property value is to be read.
452 : * @propname: name of the property to be searched.
453 : * @out_values: pointer to return value, modified only if return value is 0.
454 : * @sz: number of array elements to read
455 : *
456 : * Search for a property in a device node and read 16-bit value(s) from
457 : * it. Returns 0 on success, -EINVAL if the property does not exist,
458 : * -ENODATA if property does not have a value, and -EOVERFLOW if the
459 : * property data isn't large enough.
460 : *
461 : * dts entry of array should be like:
462 : * property = /bits/ 16 <0x5000 0x6000 0x7000>;
463 : *
464 : * The out_values is modified only if a valid u16 value can be decoded.
465 : */
466 : static inline int of_property_read_u16_array(const struct device_node *np,
467 : const char *propname,
468 : u16 *out_values, size_t sz)
469 : {
470 : int ret = of_property_read_variable_u16_array(np, propname, out_values,
471 : sz, 0);
472 : if (ret >= 0)
473 : return 0;
474 : else
475 : return ret;
476 : }
477 :
478 : /**
479 : * of_property_read_u32_array - Find and read an array of 32 bit integers
480 : * from a property.
481 : *
482 : * @np: device node from which the property value is to be read.
483 : * @propname: name of the property to be searched.
484 : * @out_values: pointer to return value, modified only if return value is 0.
485 : * @sz: number of array elements to read
486 : *
487 : * Search for a property in a device node and read 32-bit value(s) from
488 : * it. Returns 0 on success, -EINVAL if the property does not exist,
489 : * -ENODATA if property does not have a value, and -EOVERFLOW if the
490 : * property data isn't large enough.
491 : *
492 : * The out_values is modified only if a valid u32 value can be decoded.
493 : */
494 : static inline int of_property_read_u32_array(const struct device_node *np,
495 : const char *propname,
496 : u32 *out_values, size_t sz)
497 : {
498 : int ret = of_property_read_variable_u32_array(np, propname, out_values,
499 : sz, 0);
500 : if (ret >= 0)
501 : return 0;
502 : else
503 : return ret;
504 : }
505 :
506 : /**
507 : * of_property_read_u64_array - Find and read an array of 64 bit integers
508 : * from a property.
509 : *
510 : * @np: device node from which the property value is to be read.
511 : * @propname: name of the property to be searched.
512 : * @out_values: pointer to return value, modified only if return value is 0.
513 : * @sz: number of array elements to read
514 : *
515 : * Search for a property in a device node and read 64-bit value(s) from
516 : * it. Returns 0 on success, -EINVAL if the property does not exist,
517 : * -ENODATA if property does not have a value, and -EOVERFLOW if the
518 : * property data isn't large enough.
519 : *
520 : * The out_values is modified only if a valid u64 value can be decoded.
521 : */
522 : static inline int of_property_read_u64_array(const struct device_node *np,
523 : const char *propname,
524 : u64 *out_values, size_t sz)
525 : {
526 : int ret = of_property_read_variable_u64_array(np, propname, out_values,
527 : sz, 0);
528 : if (ret >= 0)
529 : return 0;
530 : else
531 : return ret;
532 : }
533 :
534 : /*
535 : * struct property *prop;
536 : * const __be32 *p;
537 : * u32 u;
538 : *
539 : * of_property_for_each_u32(np, "propname", prop, p, u)
540 : * printk("U32 value: %x\n", u);
541 : */
542 : const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
543 : u32 *pu);
544 : /*
545 : * struct property *prop;
546 : * const char *s;
547 : *
548 : * of_property_for_each_string(np, "propname", prop, s)
549 : * printk("String value: %s\n", s);
550 : */
551 : const char *of_prop_next_string(struct property *prop, const char *cur);
552 :
553 : bool of_console_check(struct device_node *dn, char *name, int index);
554 :
555 : extern int of_cpu_node_to_id(struct device_node *np);
556 :
557 : int of_map_id(struct device_node *np, u32 id,
558 : const char *map_name, const char *map_mask_name,
559 : struct device_node **target, u32 *id_out);
560 :
561 : phys_addr_t of_dma_get_max_cpu_address(struct device_node *np);
562 :
563 : #else /* CONFIG_OF */
564 :
565 1 : static inline void of_core_init(void)
566 : {
567 1 : }
568 :
569 0 : static inline bool is_of_node(const struct fwnode_handle *fwnode)
570 : {
571 0 : return false;
572 : }
573 :
574 5 : static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode)
575 : {
576 3 : return NULL;
577 : }
578 :
579 : static inline bool of_node_name_eq(const struct device_node *np, const char *name)
580 : {
581 : return false;
582 : }
583 :
584 : static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix)
585 : {
586 : return false;
587 : }
588 :
589 0 : static inline const char* of_node_full_name(const struct device_node *np)
590 : {
591 0 : return "<no-node>";
592 : }
593 :
594 : static inline struct device_node *of_find_node_by_name(struct device_node *from,
595 : const char *name)
596 : {
597 : return NULL;
598 : }
599 :
600 : static inline struct device_node *of_find_node_by_type(struct device_node *from,
601 : const char *type)
602 : {
603 : return NULL;
604 : }
605 :
606 1 : static inline struct device_node *of_find_matching_node_and_match(
607 : struct device_node *from,
608 : const struct of_device_id *matches,
609 : const struct of_device_id **match)
610 : {
611 1 : return NULL;
612 : }
613 :
614 : static inline struct device_node *of_find_node_by_path(const char *path)
615 : {
616 : return NULL;
617 : }
618 :
619 : static inline struct device_node *of_find_node_opts_by_path(const char *path,
620 : const char **opts)
621 : {
622 : return NULL;
623 : }
624 :
625 : static inline struct device_node *of_find_node_by_phandle(phandle handle)
626 : {
627 : return NULL;
628 : }
629 :
630 : static inline struct device_node *of_get_parent(const struct device_node *node)
631 : {
632 : return NULL;
633 : }
634 :
635 : static inline struct device_node *of_get_next_parent(struct device_node *node)
636 : {
637 : return NULL;
638 : }
639 :
640 : static inline struct device_node *of_get_next_child(
641 : const struct device_node *node, struct device_node *prev)
642 : {
643 : return NULL;
644 : }
645 :
646 : static inline struct device_node *of_get_next_available_child(
647 : const struct device_node *node, struct device_node *prev)
648 : {
649 : return NULL;
650 : }
651 :
652 : static inline struct device_node *of_find_node_with_property(
653 : struct device_node *from, const char *prop_name)
654 : {
655 : return NULL;
656 : }
657 :
658 : #define of_fwnode_handle(node) NULL
659 :
660 0 : static inline bool of_have_populated_dt(void)
661 : {
662 0 : return false;
663 : }
664 :
665 : static inline struct device_node *of_get_compatible_child(const struct device_node *parent,
666 : const char *compatible)
667 : {
668 : return NULL;
669 : }
670 :
671 : static inline struct device_node *of_get_child_by_name(
672 : const struct device_node *node,
673 : const char *name)
674 : {
675 : return NULL;
676 : }
677 :
678 : static inline int of_device_is_compatible(const struct device_node *device,
679 : const char *name)
680 : {
681 : return 0;
682 : }
683 :
684 : static inline int of_device_compatible_match(struct device_node *device,
685 : const char *const *compat)
686 : {
687 : return 0;
688 : }
689 :
690 : static inline bool of_device_is_available(const struct device_node *device)
691 : {
692 : return false;
693 : }
694 :
695 : static inline bool of_device_is_big_endian(const struct device_node *device)
696 : {
697 : return false;
698 : }
699 :
700 : static inline struct property *of_find_property(const struct device_node *np,
701 : const char *name,
702 : int *lenp)
703 : {
704 : return NULL;
705 : }
706 :
707 : static inline struct device_node *of_find_compatible_node(
708 : struct device_node *from,
709 : const char *type,
710 : const char *compat)
711 : {
712 : return NULL;
713 : }
714 :
715 : static inline int of_property_count_elems_of_size(const struct device_node *np,
716 : const char *propname, int elem_size)
717 : {
718 : return -ENOSYS;
719 : }
720 :
721 : static inline int of_property_read_u8_array(const struct device_node *np,
722 : const char *propname, u8 *out_values, size_t sz)
723 : {
724 : return -ENOSYS;
725 : }
726 :
727 : static inline int of_property_read_u16_array(const struct device_node *np,
728 : const char *propname, u16 *out_values, size_t sz)
729 : {
730 : return -ENOSYS;
731 : }
732 :
733 : static inline int of_property_read_u32_array(const struct device_node *np,
734 : const char *propname,
735 : u32 *out_values, size_t sz)
736 : {
737 : return -ENOSYS;
738 : }
739 :
740 : static inline int of_property_read_u64_array(const struct device_node *np,
741 : const char *propname,
742 : u64 *out_values, size_t sz)
743 : {
744 : return -ENOSYS;
745 : }
746 :
747 : static inline int of_property_read_u32_index(const struct device_node *np,
748 : const char *propname, u32 index, u32 *out_value)
749 : {
750 : return -ENOSYS;
751 : }
752 :
753 : static inline int of_property_read_u64_index(const struct device_node *np,
754 : const char *propname, u32 index, u64 *out_value)
755 : {
756 : return -ENOSYS;
757 : }
758 :
759 : static inline const void *of_get_property(const struct device_node *node,
760 : const char *name,
761 : int *lenp)
762 : {
763 : return NULL;
764 : }
765 :
766 4 : static inline struct device_node *of_get_cpu_node(int cpu,
767 : unsigned int *thread)
768 : {
769 4 : return NULL;
770 : }
771 :
772 : static inline struct device_node *of_get_next_cpu_node(struct device_node *prev)
773 : {
774 : return NULL;
775 : }
776 :
777 : static inline struct device_node *of_get_cpu_state_node(struct device_node *cpu_node,
778 : int index)
779 : {
780 : return NULL;
781 : }
782 :
783 : static inline int of_n_addr_cells(struct device_node *np)
784 : {
785 : return 0;
786 :
787 : }
788 : static inline int of_n_size_cells(struct device_node *np)
789 : {
790 : return 0;
791 : }
792 :
793 : static inline int of_property_read_variable_u8_array(const struct device_node *np,
794 : const char *propname, u8 *out_values,
795 : size_t sz_min, size_t sz_max)
796 : {
797 : return -ENOSYS;
798 : }
799 :
800 : static inline int of_property_read_variable_u16_array(const struct device_node *np,
801 : const char *propname, u16 *out_values,
802 : size_t sz_min, size_t sz_max)
803 : {
804 : return -ENOSYS;
805 : }
806 :
807 : static inline int of_property_read_variable_u32_array(const struct device_node *np,
808 : const char *propname,
809 : u32 *out_values,
810 : size_t sz_min,
811 : size_t sz_max)
812 : {
813 : return -ENOSYS;
814 : }
815 :
816 : static inline int of_property_read_u64(const struct device_node *np,
817 : const char *propname, u64 *out_value)
818 : {
819 : return -ENOSYS;
820 : }
821 :
822 : static inline int of_property_read_variable_u64_array(const struct device_node *np,
823 : const char *propname,
824 : u64 *out_values,
825 : size_t sz_min,
826 : size_t sz_max)
827 : {
828 : return -ENOSYS;
829 : }
830 :
831 : static inline int of_property_read_string(const struct device_node *np,
832 : const char *propname,
833 : const char **out_string)
834 : {
835 : return -ENOSYS;
836 : }
837 :
838 : static inline int of_property_match_string(const struct device_node *np,
839 : const char *propname,
840 : const char *string)
841 : {
842 : return -ENOSYS;
843 : }
844 :
845 : static inline int of_property_read_string_helper(const struct device_node *np,
846 : const char *propname,
847 : const char **out_strs, size_t sz, int index)
848 : {
849 : return -ENOSYS;
850 : }
851 :
852 : static inline struct device_node *of_parse_phandle(const struct device_node *np,
853 : const char *phandle_name,
854 : int index)
855 : {
856 : return NULL;
857 : }
858 :
859 : static inline int of_parse_phandle_with_args(const struct device_node *np,
860 : const char *list_name,
861 : const char *cells_name,
862 : int index,
863 : struct of_phandle_args *out_args)
864 : {
865 : return -ENOSYS;
866 : }
867 :
868 : static inline int of_parse_phandle_with_args_map(const struct device_node *np,
869 : const char *list_name,
870 : const char *stem_name,
871 : int index,
872 : struct of_phandle_args *out_args)
873 : {
874 : return -ENOSYS;
875 : }
876 :
877 : static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
878 : const char *list_name, int cells_count, int index,
879 : struct of_phandle_args *out_args)
880 : {
881 : return -ENOSYS;
882 : }
883 :
884 : static inline int of_count_phandle_with_args(struct device_node *np,
885 : const char *list_name,
886 : const char *cells_name)
887 : {
888 : return -ENOSYS;
889 : }
890 :
891 : static inline int of_phandle_iterator_init(struct of_phandle_iterator *it,
892 : const struct device_node *np,
893 : const char *list_name,
894 : const char *cells_name,
895 : int cell_count)
896 : {
897 : return -ENOSYS;
898 : }
899 :
900 : static inline int of_phandle_iterator_next(struct of_phandle_iterator *it)
901 : {
902 : return -ENOSYS;
903 : }
904 :
905 : static inline int of_phandle_iterator_args(struct of_phandle_iterator *it,
906 : uint32_t *args,
907 : int size)
908 : {
909 : return 0;
910 : }
911 :
912 : static inline int of_alias_get_id(struct device_node *np, const char *stem)
913 : {
914 : return -ENOSYS;
915 : }
916 :
917 : static inline int of_alias_get_highest_id(const char *stem)
918 : {
919 : return -ENOSYS;
920 : }
921 :
922 : static inline int of_alias_get_alias_list(const struct of_device_id *matches,
923 : const char *stem, unsigned long *bitmap,
924 : unsigned int nbits)
925 : {
926 : return -ENOSYS;
927 : }
928 :
929 : static inline int of_machine_is_compatible(const char *compat)
930 : {
931 : return 0;
932 : }
933 :
934 : static inline int of_remove_property(struct device_node *np, struct property *prop)
935 : {
936 : return 0;
937 : }
938 :
939 : static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
940 : {
941 : return false;
942 : }
943 :
944 : static inline const __be32 *of_prop_next_u32(struct property *prop,
945 : const __be32 *cur, u32 *pu)
946 : {
947 : return NULL;
948 : }
949 :
950 : static inline const char *of_prop_next_string(struct property *prop,
951 : const char *cur)
952 : {
953 : return NULL;
954 : }
955 :
956 : static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
957 : {
958 : return 0;
959 : }
960 :
961 : static inline int of_node_test_and_set_flag(struct device_node *n,
962 : unsigned long flag)
963 : {
964 : return 0;
965 : }
966 :
967 : static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
968 : {
969 : }
970 :
971 : static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
972 : {
973 : }
974 :
975 : static inline int of_property_check_flag(struct property *p, unsigned long flag)
976 : {
977 : return 0;
978 : }
979 :
980 : static inline void of_property_set_flag(struct property *p, unsigned long flag)
981 : {
982 : }
983 :
984 : static inline void of_property_clear_flag(struct property *p, unsigned long flag)
985 : {
986 : }
987 :
988 : static inline int of_cpu_node_to_id(struct device_node *np)
989 : {
990 : return -ENODEV;
991 : }
992 :
993 : static inline int of_map_id(struct device_node *np, u32 id,
994 : const char *map_name, const char *map_mask_name,
995 : struct device_node **target, u32 *id_out)
996 : {
997 : return -EINVAL;
998 : }
999 :
1000 : static inline phys_addr_t of_dma_get_max_cpu_address(struct device_node *np)
1001 : {
1002 : return PHYS_ADDR_MAX;
1003 : }
1004 :
1005 : #define of_match_ptr(_ptr) NULL
1006 : #define of_match_node(_matches, _node) NULL
1007 : #endif /* CONFIG_OF */
1008 :
1009 : /* Default string compare functions, Allow arch asm/prom.h to override */
1010 : #if !defined(of_compat_cmp)
1011 : #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
1012 : #define of_prop_cmp(s1, s2) strcmp((s1), (s2))
1013 : #define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
1014 : #endif
1015 :
1016 : static inline int of_prop_val_eq(struct property *p1, struct property *p2)
1017 : {
1018 : return p1->length == p2->length &&
1019 : !memcmp(p1->value, p2->value, (size_t)p1->length);
1020 : }
1021 :
1022 : #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
1023 : extern int of_node_to_nid(struct device_node *np);
1024 : #else
1025 2 : static inline int of_node_to_nid(struct device_node *device)
1026 : {
1027 2 : return NUMA_NO_NODE;
1028 : }
1029 : #endif
1030 :
1031 : #ifdef CONFIG_OF_NUMA
1032 : extern int of_numa_init(void);
1033 : #else
1034 : static inline int of_numa_init(void)
1035 : {
1036 : return -ENOSYS;
1037 : }
1038 : #endif
1039 :
1040 1 : static inline struct device_node *of_find_matching_node(
1041 : struct device_node *from,
1042 : const struct of_device_id *matches)
1043 : {
1044 1 : return of_find_matching_node_and_match(from, matches, NULL);
1045 : }
1046 :
1047 : static inline const char *of_node_get_device_type(const struct device_node *np)
1048 : {
1049 : return of_get_property(np, "device_type", NULL);
1050 : }
1051 :
1052 : static inline bool of_node_is_type(const struct device_node *np, const char *type)
1053 : {
1054 : const char *match = of_node_get_device_type(np);
1055 :
1056 : return np && match && type && !strcmp(match, type);
1057 : }
1058 :
1059 : /**
1060 : * of_property_count_u8_elems - Count the number of u8 elements in a property
1061 : *
1062 : * @np: device node from which the property value is to be read.
1063 : * @propname: name of the property to be searched.
1064 : *
1065 : * Search for a property in a device node and count the number of u8 elements
1066 : * in it. Returns number of elements on sucess, -EINVAL if the property does
1067 : * not exist or its length does not match a multiple of u8 and -ENODATA if the
1068 : * property does not have a value.
1069 : */
1070 : static inline int of_property_count_u8_elems(const struct device_node *np,
1071 : const char *propname)
1072 : {
1073 : return of_property_count_elems_of_size(np, propname, sizeof(u8));
1074 : }
1075 :
1076 : /**
1077 : * of_property_count_u16_elems - Count the number of u16 elements in a property
1078 : *
1079 : * @np: device node from which the property value is to be read.
1080 : * @propname: name of the property to be searched.
1081 : *
1082 : * Search for a property in a device node and count the number of u16 elements
1083 : * in it. Returns number of elements on sucess, -EINVAL if the property does
1084 : * not exist or its length does not match a multiple of u16 and -ENODATA if the
1085 : * property does not have a value.
1086 : */
1087 : static inline int of_property_count_u16_elems(const struct device_node *np,
1088 : const char *propname)
1089 : {
1090 : return of_property_count_elems_of_size(np, propname, sizeof(u16));
1091 : }
1092 :
1093 : /**
1094 : * of_property_count_u32_elems - Count the number of u32 elements in a property
1095 : *
1096 : * @np: device node from which the property value is to be read.
1097 : * @propname: name of the property to be searched.
1098 : *
1099 : * Search for a property in a device node and count the number of u32 elements
1100 : * in it. Returns number of elements on sucess, -EINVAL if the property does
1101 : * not exist or its length does not match a multiple of u32 and -ENODATA if the
1102 : * property does not have a value.
1103 : */
1104 : static inline int of_property_count_u32_elems(const struct device_node *np,
1105 : const char *propname)
1106 : {
1107 : return of_property_count_elems_of_size(np, propname, sizeof(u32));
1108 : }
1109 :
1110 : /**
1111 : * of_property_count_u64_elems - Count the number of u64 elements in a property
1112 : *
1113 : * @np: device node from which the property value is to be read.
1114 : * @propname: name of the property to be searched.
1115 : *
1116 : * Search for a property in a device node and count the number of u64 elements
1117 : * in it. Returns number of elements on sucess, -EINVAL if the property does
1118 : * not exist or its length does not match a multiple of u64 and -ENODATA if the
1119 : * property does not have a value.
1120 : */
1121 : static inline int of_property_count_u64_elems(const struct device_node *np,
1122 : const char *propname)
1123 : {
1124 : return of_property_count_elems_of_size(np, propname, sizeof(u64));
1125 : }
1126 :
1127 : /**
1128 : * of_property_read_string_array() - Read an array of strings from a multiple
1129 : * strings property.
1130 : * @np: device node from which the property value is to be read.
1131 : * @propname: name of the property to be searched.
1132 : * @out_strs: output array of string pointers.
1133 : * @sz: number of array elements to read.
1134 : *
1135 : * Search for a property in a device tree node and retrieve a list of
1136 : * terminated string values (pointer to data, not a copy) in that property.
1137 : *
1138 : * If @out_strs is NULL, the number of strings in the property is returned.
1139 : */
1140 : static inline int of_property_read_string_array(const struct device_node *np,
1141 : const char *propname, const char **out_strs,
1142 : size_t sz)
1143 : {
1144 : return of_property_read_string_helper(np, propname, out_strs, sz, 0);
1145 : }
1146 :
1147 : /**
1148 : * of_property_count_strings() - Find and return the number of strings from a
1149 : * multiple strings property.
1150 : * @np: device node from which the property value is to be read.
1151 : * @propname: name of the property to be searched.
1152 : *
1153 : * Search for a property in a device tree node and retrieve the number of null
1154 : * terminated string contain in it. Returns the number of strings on
1155 : * success, -EINVAL if the property does not exist, -ENODATA if property
1156 : * does not have a value, and -EILSEQ if the string is not null-terminated
1157 : * within the length of the property data.
1158 : */
1159 : static inline int of_property_count_strings(const struct device_node *np,
1160 : const char *propname)
1161 : {
1162 : return of_property_read_string_helper(np, propname, NULL, 0, 0);
1163 : }
1164 :
1165 : /**
1166 : * of_property_read_string_index() - Find and read a string from a multiple
1167 : * strings property.
1168 : * @np: device node from which the property value is to be read.
1169 : * @propname: name of the property to be searched.
1170 : * @index: index of the string in the list of strings
1171 : * @out_string: pointer to null terminated return string, modified only if
1172 : * return value is 0.
1173 : *
1174 : * Search for a property in a device tree node and retrieve a null
1175 : * terminated string value (pointer to data, not a copy) in the list of strings
1176 : * contained in that property.
1177 : * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
1178 : * property does not have a value, and -EILSEQ if the string is not
1179 : * null-terminated within the length of the property data.
1180 : *
1181 : * The out_string pointer is modified only if a valid string can be decoded.
1182 : */
1183 : static inline int of_property_read_string_index(const struct device_node *np,
1184 : const char *propname,
1185 : int index, const char **output)
1186 : {
1187 : int rc = of_property_read_string_helper(np, propname, output, 1, index);
1188 : return rc < 0 ? rc : 0;
1189 : }
1190 :
1191 : /**
1192 : * of_property_read_bool - Find a property
1193 : * @np: device node from which the property value is to be read.
1194 : * @propname: name of the property to be searched.
1195 : *
1196 : * Search for a property in a device node.
1197 : * Returns true if the property exists false otherwise.
1198 : */
1199 : static inline bool of_property_read_bool(const struct device_node *np,
1200 : const char *propname)
1201 : {
1202 : struct property *prop = of_find_property(np, propname, NULL);
1203 :
1204 : return prop ? true : false;
1205 : }
1206 :
1207 : static inline int of_property_read_u8(const struct device_node *np,
1208 : const char *propname,
1209 : u8 *out_value)
1210 : {
1211 : return of_property_read_u8_array(np, propname, out_value, 1);
1212 : }
1213 :
1214 : static inline int of_property_read_u16(const struct device_node *np,
1215 : const char *propname,
1216 : u16 *out_value)
1217 : {
1218 : return of_property_read_u16_array(np, propname, out_value, 1);
1219 : }
1220 :
1221 : static inline int of_property_read_u32(const struct device_node *np,
1222 : const char *propname,
1223 : u32 *out_value)
1224 : {
1225 : return of_property_read_u32_array(np, propname, out_value, 1);
1226 : }
1227 :
1228 : static inline int of_property_read_s32(const struct device_node *np,
1229 : const char *propname,
1230 : s32 *out_value)
1231 : {
1232 : return of_property_read_u32(np, propname, (u32*) out_value);
1233 : }
1234 :
1235 : #define of_for_each_phandle(it, err, np, ln, cn, cc) \
1236 : for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \
1237 : err = of_phandle_iterator_next(it); \
1238 : err == 0; \
1239 : err = of_phandle_iterator_next(it))
1240 :
1241 : #define of_property_for_each_u32(np, propname, prop, p, u) \
1242 : for (prop = of_find_property(np, propname, NULL), \
1243 : p = of_prop_next_u32(prop, NULL, &u); \
1244 : p; \
1245 : p = of_prop_next_u32(prop, p, &u))
1246 :
1247 : #define of_property_for_each_string(np, propname, prop, s) \
1248 : for (prop = of_find_property(np, propname, NULL), \
1249 : s = of_prop_next_string(prop, NULL); \
1250 : s; \
1251 : s = of_prop_next_string(prop, s))
1252 :
1253 : #define for_each_node_by_name(dn, name) \
1254 : for (dn = of_find_node_by_name(NULL, name); dn; \
1255 : dn = of_find_node_by_name(dn, name))
1256 : #define for_each_node_by_type(dn, type) \
1257 : for (dn = of_find_node_by_type(NULL, type); dn; \
1258 : dn = of_find_node_by_type(dn, type))
1259 : #define for_each_compatible_node(dn, type, compatible) \
1260 : for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
1261 : dn = of_find_compatible_node(dn, type, compatible))
1262 : #define for_each_matching_node(dn, matches) \
1263 : for (dn = of_find_matching_node(NULL, matches); dn; \
1264 : dn = of_find_matching_node(dn, matches))
1265 : #define for_each_matching_node_and_match(dn, matches, match) \
1266 : for (dn = of_find_matching_node_and_match(NULL, matches, match); \
1267 : dn; dn = of_find_matching_node_and_match(dn, matches, match))
1268 :
1269 : #define for_each_child_of_node(parent, child) \
1270 : for (child = of_get_next_child(parent, NULL); child != NULL; \
1271 : child = of_get_next_child(parent, child))
1272 : #define for_each_available_child_of_node(parent, child) \
1273 : for (child = of_get_next_available_child(parent, NULL); child != NULL; \
1274 : child = of_get_next_available_child(parent, child))
1275 :
1276 : #define for_each_of_cpu_node(cpu) \
1277 : for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \
1278 : cpu = of_get_next_cpu_node(cpu))
1279 :
1280 : #define for_each_node_with_property(dn, prop_name) \
1281 : for (dn = of_find_node_with_property(NULL, prop_name); dn; \
1282 : dn = of_find_node_with_property(dn, prop_name))
1283 :
1284 : static inline int of_get_child_count(const struct device_node *np)
1285 : {
1286 : struct device_node *child;
1287 : int num = 0;
1288 :
1289 : for_each_child_of_node(np, child)
1290 : num++;
1291 :
1292 : return num;
1293 : }
1294 :
1295 : static inline int of_get_available_child_count(const struct device_node *np)
1296 : {
1297 : struct device_node *child;
1298 : int num = 0;
1299 :
1300 : for_each_available_child_of_node(np, child)
1301 : num++;
1302 :
1303 : return num;
1304 : }
1305 :
1306 : #if defined(CONFIG_OF) && !defined(MODULE)
1307 : #define _OF_DECLARE(table, name, compat, fn, fn_type) \
1308 : static const struct of_device_id __of_table_##name \
1309 : __used __section("__" #table "_of_table") \
1310 : __aligned(__alignof__(struct of_device_id)) \
1311 : = { .compatible = compat, \
1312 : .data = (fn == (fn_type)NULL) ? fn : fn }
1313 : #else
1314 : #define _OF_DECLARE(table, name, compat, fn, fn_type) \
1315 : static const struct of_device_id __of_table_##name \
1316 : __attribute__((unused)) \
1317 : = { .compatible = compat, \
1318 : .data = (fn == (fn_type)NULL) ? fn : fn }
1319 : #endif
1320 :
1321 : typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
1322 : typedef int (*of_init_fn_1_ret)(struct device_node *);
1323 : typedef void (*of_init_fn_1)(struct device_node *);
1324 :
1325 : #define OF_DECLARE_1(table, name, compat, fn) \
1326 : _OF_DECLARE(table, name, compat, fn, of_init_fn_1)
1327 : #define OF_DECLARE_1_RET(table, name, compat, fn) \
1328 : _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret)
1329 : #define OF_DECLARE_2(table, name, compat, fn) \
1330 : _OF_DECLARE(table, name, compat, fn, of_init_fn_2)
1331 :
1332 : /**
1333 : * struct of_changeset_entry - Holds a changeset entry
1334 : *
1335 : * @node: list_head for the log list
1336 : * @action: notifier action
1337 : * @np: pointer to the device node affected
1338 : * @prop: pointer to the property affected
1339 : * @old_prop: hold a pointer to the original property
1340 : *
1341 : * Every modification of the device tree during a changeset
1342 : * is held in a list of of_changeset_entry structures.
1343 : * That way we can recover from a partial application, or we can
1344 : * revert the changeset
1345 : */
1346 : struct of_changeset_entry {
1347 : struct list_head node;
1348 : unsigned long action;
1349 : struct device_node *np;
1350 : struct property *prop;
1351 : struct property *old_prop;
1352 : };
1353 :
1354 : /**
1355 : * struct of_changeset - changeset tracker structure
1356 : *
1357 : * @entries: list_head for the changeset entries
1358 : *
1359 : * changesets are a convenient way to apply bulk changes to the
1360 : * live tree. In case of an error, changes are rolled-back.
1361 : * changesets live on after initial application, and if not
1362 : * destroyed after use, they can be reverted in one single call.
1363 : */
1364 : struct of_changeset {
1365 : struct list_head entries;
1366 : };
1367 :
1368 : enum of_reconfig_change {
1369 : OF_RECONFIG_NO_CHANGE = 0,
1370 : OF_RECONFIG_CHANGE_ADD,
1371 : OF_RECONFIG_CHANGE_REMOVE,
1372 : };
1373 :
1374 : #ifdef CONFIG_OF_DYNAMIC
1375 : extern int of_reconfig_notifier_register(struct notifier_block *);
1376 : extern int of_reconfig_notifier_unregister(struct notifier_block *);
1377 : extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
1378 : extern int of_reconfig_get_state_change(unsigned long action,
1379 : struct of_reconfig_data *arg);
1380 :
1381 : extern void of_changeset_init(struct of_changeset *ocs);
1382 : extern void of_changeset_destroy(struct of_changeset *ocs);
1383 : extern int of_changeset_apply(struct of_changeset *ocs);
1384 : extern int of_changeset_revert(struct of_changeset *ocs);
1385 : extern int of_changeset_action(struct of_changeset *ocs,
1386 : unsigned long action, struct device_node *np,
1387 : struct property *prop);
1388 :
1389 : static inline int of_changeset_attach_node(struct of_changeset *ocs,
1390 : struct device_node *np)
1391 : {
1392 : return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
1393 : }
1394 :
1395 : static inline int of_changeset_detach_node(struct of_changeset *ocs,
1396 : struct device_node *np)
1397 : {
1398 : return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
1399 : }
1400 :
1401 : static inline int of_changeset_add_property(struct of_changeset *ocs,
1402 : struct device_node *np, struct property *prop)
1403 : {
1404 : return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
1405 : }
1406 :
1407 : static inline int of_changeset_remove_property(struct of_changeset *ocs,
1408 : struct device_node *np, struct property *prop)
1409 : {
1410 : return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1411 : }
1412 :
1413 : static inline int of_changeset_update_property(struct of_changeset *ocs,
1414 : struct device_node *np, struct property *prop)
1415 : {
1416 : return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
1417 : }
1418 : #else /* CONFIG_OF_DYNAMIC */
1419 : static inline int of_reconfig_notifier_register(struct notifier_block *nb)
1420 : {
1421 : return -EINVAL;
1422 : }
1423 : static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
1424 : {
1425 : return -EINVAL;
1426 : }
1427 : static inline int of_reconfig_notify(unsigned long action,
1428 : struct of_reconfig_data *arg)
1429 : {
1430 : return -EINVAL;
1431 : }
1432 : static inline int of_reconfig_get_state_change(unsigned long action,
1433 : struct of_reconfig_data *arg)
1434 : {
1435 : return -EINVAL;
1436 : }
1437 : #endif /* CONFIG_OF_DYNAMIC */
1438 :
1439 : /**
1440 : * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node
1441 : * @np: Pointer to the given device_node
1442 : *
1443 : * return true if present false otherwise
1444 : */
1445 : static inline bool of_device_is_system_power_controller(const struct device_node *np)
1446 : {
1447 : return of_property_read_bool(np, "system-power-controller");
1448 : }
1449 :
1450 : /**
1451 : * Overlay support
1452 : */
1453 :
1454 : enum of_overlay_notify_action {
1455 : OF_OVERLAY_PRE_APPLY = 0,
1456 : OF_OVERLAY_POST_APPLY,
1457 : OF_OVERLAY_PRE_REMOVE,
1458 : OF_OVERLAY_POST_REMOVE,
1459 : };
1460 :
1461 : struct of_overlay_notify_data {
1462 : struct device_node *overlay;
1463 : struct device_node *target;
1464 : };
1465 :
1466 : #ifdef CONFIG_OF_OVERLAY
1467 :
1468 : int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size,
1469 : int *ovcs_id);
1470 : int of_overlay_remove(int *ovcs_id);
1471 : int of_overlay_remove_all(void);
1472 :
1473 : int of_overlay_notifier_register(struct notifier_block *nb);
1474 : int of_overlay_notifier_unregister(struct notifier_block *nb);
1475 :
1476 : #else
1477 :
1478 : static inline int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size,
1479 : int *ovcs_id)
1480 : {
1481 : return -ENOTSUPP;
1482 : }
1483 :
1484 : static inline int of_overlay_remove(int *ovcs_id)
1485 : {
1486 : return -ENOTSUPP;
1487 : }
1488 :
1489 : static inline int of_overlay_remove_all(void)
1490 : {
1491 : return -ENOTSUPP;
1492 : }
1493 :
1494 : static inline int of_overlay_notifier_register(struct notifier_block *nb)
1495 : {
1496 : return 0;
1497 : }
1498 :
1499 : static inline int of_overlay_notifier_unregister(struct notifier_block *nb)
1500 : {
1501 : return 0;
1502 : }
1503 :
1504 : #endif
1505 :
1506 : #endif /* _LINUX_OF_H */
|
