Branch data 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 : 55752 : kobject_init(&node->kobj, &of_node_ktype);
110 : : #endif
111 : 55752 : node->fwnode.ops = &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 : : static inline struct device_node *of_node_get(struct device_node *node)
126 : : {
127 : : return node;
128 : : }
129 : : 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 [ + + - + : 51712 : 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 : 808 : return of_root != NULL;
181 : : }
182 : :
183 : : static inline bool of_node_is_root(const struct device_node *node)
184 : : {
185 [ + - + - ]: 808 : 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 : 10908 : 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 : 2828 : set_bit(flag, &n->_flags);
202 : : }
203 : :
204 : : static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
205 : : {
206 : 0 : 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 : 0 : 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 [ + + + + : 154732 : for (; size--; cell++)
+ + + + #
# # # # #
# # # # +
+ + + + +
+ + ]
238 : 154732 : r = (r << 32) | be32_to_cpu(*cell);
239 : 154732 : 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 : 404 : 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 [ + - # # : 234320 : 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 : 0 : static inline struct device_node *of_find_node_by_path(const char *path)
281 : : {
282 : 25878 : 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 : :
355 : : #define for_each_property_of_node(dn, pp) \
356 : : for (pp = dn->properties; pp != NULL; pp = pp->next)
357 : :
358 : : extern int of_n_addr_cells(struct device_node *np);
359 : : extern int of_n_size_cells(struct device_node *np);
360 : : extern const struct of_device_id *of_match_node(
361 : : const struct of_device_id *matches, const struct device_node *node);
362 : : extern int of_modalias_node(struct device_node *node, char *modalias, int len);
363 : : extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
364 : : extern struct device_node *of_parse_phandle(const struct device_node *np,
365 : : const char *phandle_name,
366 : : int index);
367 : : extern int of_parse_phandle_with_args(const struct device_node *np,
368 : : const char *list_name, const char *cells_name, int index,
369 : : struct of_phandle_args *out_args);
370 : : extern int of_parse_phandle_with_args_map(const struct device_node *np,
371 : : const char *list_name, const char *stem_name, int index,
372 : : struct of_phandle_args *out_args);
373 : : extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
374 : : const char *list_name, int cells_count, int index,
375 : : struct of_phandle_args *out_args);
376 : : extern int of_count_phandle_with_args(const struct device_node *np,
377 : : const char *list_name, const char *cells_name);
378 : :
379 : : /* phandle iterator functions */
380 : : extern int of_phandle_iterator_init(struct of_phandle_iterator *it,
381 : : const struct device_node *np,
382 : : const char *list_name,
383 : : const char *cells_name,
384 : : int cell_count);
385 : :
386 : : extern int of_phandle_iterator_next(struct of_phandle_iterator *it);
387 : : extern int of_phandle_iterator_args(struct of_phandle_iterator *it,
388 : : uint32_t *args,
389 : : int size);
390 : :
391 : : extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
392 : : extern int of_alias_get_id(struct device_node *np, const char *stem);
393 : : extern int of_alias_get_highest_id(const char *stem);
394 : : extern int of_alias_get_alias_list(const struct of_device_id *matches,
395 : : const char *stem, unsigned long *bitmap,
396 : : unsigned int nbits);
397 : :
398 : : extern int of_machine_is_compatible(const char *compat);
399 : :
400 : : extern int of_add_property(struct device_node *np, struct property *prop);
401 : : extern int of_remove_property(struct device_node *np, struct property *prop);
402 : : extern int of_update_property(struct device_node *np, struct property *newprop);
403 : :
404 : : /* For updating the device tree at runtime */
405 : : #define OF_RECONFIG_ATTACH_NODE 0x0001
406 : : #define OF_RECONFIG_DETACH_NODE 0x0002
407 : : #define OF_RECONFIG_ADD_PROPERTY 0x0003
408 : : #define OF_RECONFIG_REMOVE_PROPERTY 0x0004
409 : : #define OF_RECONFIG_UPDATE_PROPERTY 0x0005
410 : :
411 : : extern int of_attach_node(struct device_node *);
412 : : extern int of_detach_node(struct device_node *);
413 : :
414 : : #define of_match_ptr(_ptr) (_ptr)
415 : :
416 : : /**
417 : : * of_property_read_u8_array - Find and read an array of u8 from a property.
418 : : *
419 : : * @np: device node from which the property value is to be read.
420 : : * @propname: name of the property to be searched.
421 : : * @out_values: pointer to return value, modified only if return value is 0.
422 : : * @sz: number of array elements to read
423 : : *
424 : : * Search for a property in a device node and read 8-bit value(s) from
425 : : * it. Returns 0 on success, -EINVAL if the property does not exist,
426 : : * -ENODATA if property does not have a value, and -EOVERFLOW if the
427 : : * property data isn't large enough.
428 : : *
429 : : * dts entry of array should be like:
430 : : * property = /bits/ 8 <0x50 0x60 0x70>;
431 : : *
432 : : * The out_values is modified only if a valid u8 value can be decoded.
433 : : */
434 : : static inline int of_property_read_u8_array(const struct device_node *np,
435 : : const char *propname,
436 : : u8 *out_values, size_t sz)
437 : : {
438 : 0 : int ret = of_property_read_variable_u8_array(np, propname, out_values,
439 : : sz, 0);
440 [ # # ]: 0 : if (ret >= 0)
441 : : return 0;
442 : : else
443 : : return ret;
444 : : }
445 : :
446 : : /**
447 : : * of_property_read_u16_array - Find and read an array of u16 from a property.
448 : : *
449 : : * @np: device node from which the property value is to be read.
450 : : * @propname: name of the property to be searched.
451 : : * @out_values: pointer to return value, modified only if return value is 0.
452 : : * @sz: number of array elements to read
453 : : *
454 : : * Search for a property in a device node and read 16-bit value(s) from
455 : : * it. Returns 0 on success, -EINVAL if the property does not exist,
456 : : * -ENODATA if property does not have a value, and -EOVERFLOW if the
457 : : * property data isn't large enough.
458 : : *
459 : : * dts entry of array should be like:
460 : : * property = /bits/ 16 <0x5000 0x6000 0x7000>;
461 : : *
462 : : * The out_values is modified only if a valid u16 value can be decoded.
463 : : */
464 : : static inline int of_property_read_u16_array(const struct device_node *np,
465 : : const char *propname,
466 : : u16 *out_values, size_t sz)
467 : : {
468 : 0 : int ret = of_property_read_variable_u16_array(np, propname, out_values,
469 : : sz, 0);
470 [ # # ]: 0 : if (ret >= 0)
471 : : return 0;
472 : : else
473 : : return ret;
474 : : }
475 : :
476 : : /**
477 : : * of_property_read_u32_array - Find and read an array of 32 bit integers
478 : : * from a property.
479 : : *
480 : : * @np: device node from which the property value is to be read.
481 : : * @propname: name of the property to be searched.
482 : : * @out_values: pointer to return value, modified only if return value is 0.
483 : : * @sz: number of array elements to read
484 : : *
485 : : * Search for a property in a device node and read 32-bit value(s) from
486 : : * it. Returns 0 on success, -EINVAL if the property does not exist,
487 : : * -ENODATA if property does not have a value, and -EOVERFLOW if the
488 : : * property data isn't large enough.
489 : : *
490 : : * The out_values is modified only if a valid u32 value can be decoded.
491 : : */
492 : : static inline int of_property_read_u32_array(const struct device_node *np,
493 : : const char *propname,
494 : : u32 *out_values, size_t sz)
495 : : {
496 : 431876 : int ret = of_property_read_variable_u32_array(np, propname, out_values,
497 : : sz, 0);
498 [ + + + + : 428644 : if (ret >= 0)
+ + + + +
+ + - + -
+ - + - +
- + - + -
+ - + - +
- # # # #
# # # # ]
499 : : return 0;
500 : : else
501 : : return ret;
502 : : }
503 : :
504 : : /**
505 : : * of_property_read_u64_array - Find and read an array of 64 bit integers
506 : : * from a property.
507 : : *
508 : : * @np: device node from which the property value is to be read.
509 : : * @propname: name of the property to be searched.
510 : : * @out_values: pointer to return value, modified only if return value is 0.
511 : : * @sz: number of array elements to read
512 : : *
513 : : * Search for a property in a device node and read 64-bit value(s) from
514 : : * it. Returns 0 on success, -EINVAL if the property does not exist,
515 : : * -ENODATA if property does not have a value, and -EOVERFLOW if the
516 : : * property data isn't large enough.
517 : : *
518 : : * The out_values is modified only if a valid u64 value can be decoded.
519 : : */
520 : : static inline int of_property_read_u64_array(const struct device_node *np,
521 : : const char *propname,
522 : : u64 *out_values, size_t sz)
523 : : {
524 : 0 : int ret = of_property_read_variable_u64_array(np, propname, out_values,
525 : : sz, 0);
526 [ # # ]: 0 : if (ret >= 0)
527 : : return 0;
528 : : else
529 : : return ret;
530 : : }
531 : :
532 : : /*
533 : : * struct property *prop;
534 : : * const __be32 *p;
535 : : * u32 u;
536 : : *
537 : : * of_property_for_each_u32(np, "propname", prop, p, u)
538 : : * printk("U32 value: %x\n", u);
539 : : */
540 : : const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
541 : : u32 *pu);
542 : : /*
543 : : * struct property *prop;
544 : : * const char *s;
545 : : *
546 : : * of_property_for_each_string(np, "propname", prop, s)
547 : : * printk("String value: %s\n", s);
548 : : */
549 : : const char *of_prop_next_string(struct property *prop, const char *cur);
550 : :
551 : : bool of_console_check(struct device_node *dn, char *name, int index);
552 : :
553 : : extern int of_cpu_node_to_id(struct device_node *np);
554 : :
555 : : int of_map_rid(struct device_node *np, u32 rid,
556 : : const char *map_name, const char *map_mask_name,
557 : : struct device_node **target, u32 *id_out);
558 : :
559 : : #else /* CONFIG_OF */
560 : :
561 : : static inline void of_core_init(void)
562 : : {
563 : : }
564 : :
565 : : static inline bool is_of_node(const struct fwnode_handle *fwnode)
566 : : {
567 : : return false;
568 : : }
569 : :
570 : : static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode)
571 : : {
572 : : return NULL;
573 : : }
574 : :
575 : : static inline bool of_node_name_eq(const struct device_node *np, const char *name)
576 : : {
577 : : return false;
578 : : }
579 : :
580 : : static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix)
581 : : {
582 : : return false;
583 : : }
584 : :
585 : : static inline const char* of_node_full_name(const struct device_node *np)
586 : : {
587 : : return "<no-node>";
588 : : }
589 : :
590 : : static inline struct device_node *of_find_node_by_name(struct device_node *from,
591 : : const char *name)
592 : : {
593 : : return NULL;
594 : : }
595 : :
596 : : static inline struct device_node *of_find_node_by_type(struct device_node *from,
597 : : const char *type)
598 : : {
599 : : return NULL;
600 : : }
601 : :
602 : : static inline struct device_node *of_find_matching_node_and_match(
603 : : struct device_node *from,
604 : : const struct of_device_id *matches,
605 : : const struct of_device_id **match)
606 : : {
607 : : return NULL;
608 : : }
609 : :
610 : : static inline struct device_node *of_find_node_by_path(const char *path)
611 : : {
612 : : return NULL;
613 : : }
614 : :
615 : : static inline struct device_node *of_find_node_opts_by_path(const char *path,
616 : : const char **opts)
617 : : {
618 : : return NULL;
619 : : }
620 : :
621 : : static inline struct device_node *of_find_node_by_phandle(phandle handle)
622 : : {
623 : : return NULL;
624 : : }
625 : :
626 : : static inline struct device_node *of_get_parent(const struct device_node *node)
627 : : {
628 : : return NULL;
629 : : }
630 : :
631 : : static inline struct device_node *of_get_next_child(
632 : : const struct device_node *node, struct device_node *prev)
633 : : {
634 : : return NULL;
635 : : }
636 : :
637 : : static inline struct device_node *of_get_next_available_child(
638 : : const struct device_node *node, struct device_node *prev)
639 : : {
640 : : return NULL;
641 : : }
642 : :
643 : : static inline struct device_node *of_find_node_with_property(
644 : : struct device_node *from, const char *prop_name)
645 : : {
646 : : return NULL;
647 : : }
648 : :
649 : : #define of_fwnode_handle(node) NULL
650 : :
651 : : static inline bool of_have_populated_dt(void)
652 : : {
653 : : return false;
654 : : }
655 : :
656 : : static inline struct device_node *of_get_compatible_child(const struct device_node *parent,
657 : : const char *compatible)
658 : : {
659 : : return NULL;
660 : : }
661 : :
662 : : static inline struct device_node *of_get_child_by_name(
663 : : const struct device_node *node,
664 : : const char *name)
665 : : {
666 : : return NULL;
667 : : }
668 : :
669 : : static inline int of_device_is_compatible(const struct device_node *device,
670 : : const char *name)
671 : : {
672 : : return 0;
673 : : }
674 : :
675 : : static inline int of_device_compatible_match(struct device_node *device,
676 : : const char *const *compat)
677 : : {
678 : : return 0;
679 : : }
680 : :
681 : : static inline bool of_device_is_available(const struct device_node *device)
682 : : {
683 : : return false;
684 : : }
685 : :
686 : : static inline bool of_device_is_big_endian(const struct device_node *device)
687 : : {
688 : : return false;
689 : : }
690 : :
691 : : static inline struct property *of_find_property(const struct device_node *np,
692 : : const char *name,
693 : : int *lenp)
694 : : {
695 : : return NULL;
696 : : }
697 : :
698 : : static inline struct device_node *of_find_compatible_node(
699 : : struct device_node *from,
700 : : const char *type,
701 : : const char *compat)
702 : : {
703 : : return NULL;
704 : : }
705 : :
706 : : static inline int of_property_count_elems_of_size(const struct device_node *np,
707 : : const char *propname, int elem_size)
708 : : {
709 : : return -ENOSYS;
710 : : }
711 : :
712 : : static inline int of_property_read_u8_array(const struct device_node *np,
713 : : const char *propname, u8 *out_values, size_t sz)
714 : : {
715 : : return -ENOSYS;
716 : : }
717 : :
718 : : static inline int of_property_read_u16_array(const struct device_node *np,
719 : : const char *propname, u16 *out_values, size_t sz)
720 : : {
721 : : return -ENOSYS;
722 : : }
723 : :
724 : : static inline int of_property_read_u32_array(const struct device_node *np,
725 : : const char *propname,
726 : : u32 *out_values, size_t sz)
727 : : {
728 : : return -ENOSYS;
729 : : }
730 : :
731 : : static inline int of_property_read_u64_array(const struct device_node *np,
732 : : const char *propname,
733 : : u64 *out_values, size_t sz)
734 : : {
735 : : return -ENOSYS;
736 : : }
737 : :
738 : : static inline int of_property_read_u32_index(const struct device_node *np,
739 : : const char *propname, u32 index, u32 *out_value)
740 : : {
741 : : return -ENOSYS;
742 : : }
743 : :
744 : : static inline int of_property_read_u64_index(const struct device_node *np,
745 : : const char *propname, u32 index, u64 *out_value)
746 : : {
747 : : return -ENOSYS;
748 : : }
749 : :
750 : : static inline const void *of_get_property(const struct device_node *node,
751 : : const char *name,
752 : : int *lenp)
753 : : {
754 : : return NULL;
755 : : }
756 : :
757 : : static inline struct device_node *of_get_cpu_node(int cpu,
758 : : unsigned int *thread)
759 : : {
760 : : return NULL;
761 : : }
762 : :
763 : : static inline struct device_node *of_get_next_cpu_node(struct device_node *prev)
764 : : {
765 : : return NULL;
766 : : }
767 : :
768 : : static inline int of_n_addr_cells(struct device_node *np)
769 : : {
770 : : return 0;
771 : :
772 : : }
773 : : static inline int of_n_size_cells(struct device_node *np)
774 : : {
775 : : return 0;
776 : : }
777 : :
778 : : static inline int of_property_read_variable_u8_array(const struct device_node *np,
779 : : const char *propname, u8 *out_values,
780 : : size_t sz_min, size_t sz_max)
781 : : {
782 : : return -ENOSYS;
783 : : }
784 : :
785 : : static inline int of_property_read_variable_u16_array(const struct device_node *np,
786 : : const char *propname, u16 *out_values,
787 : : size_t sz_min, size_t sz_max)
788 : : {
789 : : return -ENOSYS;
790 : : }
791 : :
792 : : static inline int of_property_read_variable_u32_array(const struct device_node *np,
793 : : const char *propname,
794 : : u32 *out_values,
795 : : size_t sz_min,
796 : : size_t sz_max)
797 : : {
798 : : return -ENOSYS;
799 : : }
800 : :
801 : : static inline int of_property_read_u64(const struct device_node *np,
802 : : const char *propname, u64 *out_value)
803 : : {
804 : : return -ENOSYS;
805 : : }
806 : :
807 : : static inline int of_property_read_variable_u64_array(const struct device_node *np,
808 : : const char *propname,
809 : : u64 *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_string(const struct device_node *np,
817 : : const char *propname,
818 : : const char **out_string)
819 : : {
820 : : return -ENOSYS;
821 : : }
822 : :
823 : : static inline int of_property_match_string(const struct device_node *np,
824 : : const char *propname,
825 : : const char *string)
826 : : {
827 : : return -ENOSYS;
828 : : }
829 : :
830 : : static inline int of_property_read_string_helper(const struct device_node *np,
831 : : const char *propname,
832 : : const char **out_strs, size_t sz, int index)
833 : : {
834 : : return -ENOSYS;
835 : : }
836 : :
837 : : static inline struct device_node *of_parse_phandle(const struct device_node *np,
838 : : const char *phandle_name,
839 : : int index)
840 : : {
841 : : return NULL;
842 : : }
843 : :
844 : : static inline int of_parse_phandle_with_args(const struct device_node *np,
845 : : const char *list_name,
846 : : const char *cells_name,
847 : : int index,
848 : : struct of_phandle_args *out_args)
849 : : {
850 : : return -ENOSYS;
851 : : }
852 : :
853 : : static inline int of_parse_phandle_with_args_map(const struct device_node *np,
854 : : const char *list_name,
855 : : const char *stem_name,
856 : : int index,
857 : : struct of_phandle_args *out_args)
858 : : {
859 : : return -ENOSYS;
860 : : }
861 : :
862 : : static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
863 : : const char *list_name, int cells_count, int index,
864 : : struct of_phandle_args *out_args)
865 : : {
866 : : return -ENOSYS;
867 : : }
868 : :
869 : : static inline int of_count_phandle_with_args(struct device_node *np,
870 : : const char *list_name,
871 : : const char *cells_name)
872 : : {
873 : : return -ENOSYS;
874 : : }
875 : :
876 : : static inline int of_phandle_iterator_init(struct of_phandle_iterator *it,
877 : : const struct device_node *np,
878 : : const char *list_name,
879 : : const char *cells_name,
880 : : int cell_count)
881 : : {
882 : : return -ENOSYS;
883 : : }
884 : :
885 : : static inline int of_phandle_iterator_next(struct of_phandle_iterator *it)
886 : : {
887 : : return -ENOSYS;
888 : : }
889 : :
890 : : static inline int of_phandle_iterator_args(struct of_phandle_iterator *it,
891 : : uint32_t *args,
892 : : int size)
893 : : {
894 : : return 0;
895 : : }
896 : :
897 : : static inline int of_alias_get_id(struct device_node *np, const char *stem)
898 : : {
899 : : return -ENOSYS;
900 : : }
901 : :
902 : : static inline int of_alias_get_highest_id(const char *stem)
903 : : {
904 : : return -ENOSYS;
905 : : }
906 : :
907 : : static inline int of_alias_get_alias_list(const struct of_device_id *matches,
908 : : const char *stem, unsigned long *bitmap,
909 : : unsigned int nbits)
910 : : {
911 : : return -ENOSYS;
912 : : }
913 : :
914 : : static inline int of_machine_is_compatible(const char *compat)
915 : : {
916 : : return 0;
917 : : }
918 : :
919 : : static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
920 : : {
921 : : return false;
922 : : }
923 : :
924 : : static inline const __be32 *of_prop_next_u32(struct property *prop,
925 : : const __be32 *cur, u32 *pu)
926 : : {
927 : : return NULL;
928 : : }
929 : :
930 : : static inline const char *of_prop_next_string(struct property *prop,
931 : : const char *cur)
932 : : {
933 : : return NULL;
934 : : }
935 : :
936 : : static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
937 : : {
938 : : return 0;
939 : : }
940 : :
941 : : static inline int of_node_test_and_set_flag(struct device_node *n,
942 : : unsigned long flag)
943 : : {
944 : : return 0;
945 : : }
946 : :
947 : : static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
948 : : {
949 : : }
950 : :
951 : : static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
952 : : {
953 : : }
954 : :
955 : : static inline int of_property_check_flag(struct property *p, unsigned long flag)
956 : : {
957 : : return 0;
958 : : }
959 : :
960 : : static inline void of_property_set_flag(struct property *p, unsigned long flag)
961 : : {
962 : : }
963 : :
964 : : static inline void of_property_clear_flag(struct property *p, unsigned long flag)
965 : : {
966 : : }
967 : :
968 : : static inline int of_cpu_node_to_id(struct device_node *np)
969 : : {
970 : : return -ENODEV;
971 : : }
972 : :
973 : : static inline int of_map_rid(struct device_node *np, u32 rid,
974 : : const char *map_name, const char *map_mask_name,
975 : : struct device_node **target, u32 *id_out)
976 : : {
977 : : return -EINVAL;
978 : : }
979 : :
980 : : #define of_match_ptr(_ptr) NULL
981 : : #define of_match_node(_matches, _node) NULL
982 : : #endif /* CONFIG_OF */
983 : :
984 : : /* Default string compare functions, Allow arch asm/prom.h to override */
985 : : #if !defined(of_compat_cmp)
986 : : #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
987 : : #define of_prop_cmp(s1, s2) strcmp((s1), (s2))
988 : : #define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
989 : : #endif
990 : :
991 : 0 : static inline int of_prop_val_eq(struct property *p1, struct property *p2)
992 : : {
993 [ # # # # ]: 0 : return p1->length == p2->length &&
994 : 0 : !memcmp(p1->value, p2->value, (size_t)p1->length);
995 : : }
996 : :
997 : : #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
998 : : extern int of_node_to_nid(struct device_node *np);
999 : : #else
1000 : : static inline int of_node_to_nid(struct device_node *device)
1001 : : {
1002 : : return NUMA_NO_NODE;
1003 : : }
1004 : : #endif
1005 : :
1006 : : #ifdef CONFIG_OF_NUMA
1007 : : extern int of_numa_init(void);
1008 : : #else
1009 : : static inline int of_numa_init(void)
1010 : : {
1011 : : return -ENOSYS;
1012 : : }
1013 : : #endif
1014 : :
1015 : : static inline struct device_node *of_find_matching_node(
1016 : : struct device_node *from,
1017 : : const struct of_device_id *matches)
1018 : : {
1019 : 808 : return of_find_matching_node_and_match(from, matches, NULL);
1020 : : }
1021 : :
1022 : : static inline const char *of_node_get_device_type(const struct device_node *np)
1023 : : {
1024 : 219382 : return of_get_property(np, "device_type", NULL);
1025 : : }
1026 : :
1027 : : static inline bool of_node_is_type(const struct device_node *np, const char *type)
1028 : : {
1029 : : const char *match = of_node_get_device_type(np);
1030 : :
1031 : : return np && match && type && !strcmp(match, type);
1032 : : }
1033 : :
1034 : : /**
1035 : : * of_property_count_u8_elems - Count the number of u8 elements in a property
1036 : : *
1037 : : * @np: device node from which the property value is to be read.
1038 : : * @propname: name of the property to be searched.
1039 : : *
1040 : : * Search for a property in a device node and count the number of u8 elements
1041 : : * in it. Returns number of elements on sucess, -EINVAL if the property does
1042 : : * not exist or its length does not match a multiple of u8 and -ENODATA if the
1043 : : * property does not have a value.
1044 : : */
1045 : : static inline int of_property_count_u8_elems(const struct device_node *np,
1046 : : const char *propname)
1047 : : {
1048 : : return of_property_count_elems_of_size(np, propname, sizeof(u8));
1049 : : }
1050 : :
1051 : : /**
1052 : : * of_property_count_u16_elems - Count the number of u16 elements in a property
1053 : : *
1054 : : * @np: device node from which the property value is to be read.
1055 : : * @propname: name of the property to be searched.
1056 : : *
1057 : : * Search for a property in a device node and count the number of u16 elements
1058 : : * in it. Returns number of elements on sucess, -EINVAL if the property does
1059 : : * not exist or its length does not match a multiple of u16 and -ENODATA if the
1060 : : * property does not have a value.
1061 : : */
1062 : : static inline int of_property_count_u16_elems(const struct device_node *np,
1063 : : const char *propname)
1064 : : {
1065 : : return of_property_count_elems_of_size(np, propname, sizeof(u16));
1066 : : }
1067 : :
1068 : : /**
1069 : : * of_property_count_u32_elems - Count the number of u32 elements in a property
1070 : : *
1071 : : * @np: device node from which the property value is to be read.
1072 : : * @propname: name of the property to be searched.
1073 : : *
1074 : : * Search for a property in a device node and count the number of u32 elements
1075 : : * in it. Returns number of elements on sucess, -EINVAL if the property does
1076 : : * not exist or its length does not match a multiple of u32 and -ENODATA if the
1077 : : * property does not have a value.
1078 : : */
1079 : : static inline int of_property_count_u32_elems(const struct device_node *np,
1080 : : const char *propname)
1081 : : {
1082 : 808 : return of_property_count_elems_of_size(np, propname, sizeof(u32));
1083 : : }
1084 : :
1085 : : /**
1086 : : * of_property_count_u64_elems - Count the number of u64 elements in a property
1087 : : *
1088 : : * @np: device node from which the property value is to be read.
1089 : : * @propname: name of the property to be searched.
1090 : : *
1091 : : * Search for a property in a device node and count the number of u64 elements
1092 : : * in it. Returns number of elements on sucess, -EINVAL if the property does
1093 : : * not exist or its length does not match a multiple of u64 and -ENODATA if the
1094 : : * property does not have a value.
1095 : : */
1096 : : static inline int of_property_count_u64_elems(const struct device_node *np,
1097 : : const char *propname)
1098 : : {
1099 : : return of_property_count_elems_of_size(np, propname, sizeof(u64));
1100 : : }
1101 : :
1102 : : /**
1103 : : * of_property_read_string_array() - Read an array of strings from a multiple
1104 : : * strings property.
1105 : : * @np: device node from which the property value is to be read.
1106 : : * @propname: name of the property to be searched.
1107 : : * @out_strs: output array of string pointers.
1108 : : * @sz: number of array elements to read.
1109 : : *
1110 : : * Search for a property in a device tree node and retrieve a list of
1111 : : * terminated string values (pointer to data, not a copy) in that property.
1112 : : *
1113 : : * If @out_strs is NULL, the number of strings in the property is returned.
1114 : : */
1115 : : static inline int of_property_read_string_array(const struct device_node *np,
1116 : : const char *propname, const char **out_strs,
1117 : : size_t sz)
1118 : : {
1119 : 2424 : return of_property_read_string_helper(np, propname, out_strs, sz, 0);
1120 : : }
1121 : :
1122 : : /**
1123 : : * of_property_count_strings() - Find and return the number of strings from a
1124 : : * multiple strings property.
1125 : : * @np: device node from which the property value is to be read.
1126 : : * @propname: name of the property to be searched.
1127 : : *
1128 : : * Search for a property in a device tree node and retrieve the number of null
1129 : : * terminated string contain in it. Returns the number of strings on
1130 : : * success, -EINVAL if the property does not exist, -ENODATA if property
1131 : : * does not have a value, and -EILSEQ if the string is not null-terminated
1132 : : * within the length of the property data.
1133 : : */
1134 : : static inline int of_property_count_strings(const struct device_node *np,
1135 : : const char *propname)
1136 : : {
1137 : 2828 : return of_property_read_string_helper(np, propname, NULL, 0, 0);
1138 : : }
1139 : :
1140 : : /**
1141 : : * of_property_read_string_index() - Find and read a string from a multiple
1142 : : * strings property.
1143 : : * @np: device node from which the property value is to be read.
1144 : : * @propname: name of the property to be searched.
1145 : : * @index: index of the string in the list of strings
1146 : : * @out_string: pointer to null terminated return string, modified only if
1147 : : * return value is 0.
1148 : : *
1149 : : * Search for a property in a device tree node and retrieve a null
1150 : : * terminated string value (pointer to data, not a copy) in the list of strings
1151 : : * contained in that property.
1152 : : * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
1153 : : * property does not have a value, and -EILSEQ if the string is not
1154 : : * null-terminated within the length of the property data.
1155 : : *
1156 : : * The out_string pointer is modified only if a valid string can be decoded.
1157 : : */
1158 : : static inline int of_property_read_string_index(const struct device_node *np,
1159 : : const char *propname,
1160 : : int index, const char **output)
1161 : : {
1162 : 30300 : int rc = of_property_read_string_helper(np, propname, output, 1, index);
1163 : : return rc < 0 ? rc : 0;
1164 : : }
1165 : :
1166 : : /**
1167 : : * of_property_read_bool - Find a property
1168 : : * @np: device node from which the property value is to be read.
1169 : : * @propname: name of the property to be searched.
1170 : : *
1171 : : * Search for a property in a device node.
1172 : : * Returns true if the property exists false otherwise.
1173 : : */
1174 : : static inline bool of_property_read_bool(const struct device_node *np,
1175 : : const char *propname)
1176 : : {
1177 : 113120 : struct property *prop = of_find_property(np, propname, NULL);
1178 : :
1179 : 23028 : return prop ? true : false;
1180 : : }
1181 : :
1182 : : static inline int of_property_read_u8(const struct device_node *np,
1183 : : const char *propname,
1184 : : u8 *out_value)
1185 : : {
1186 : : return of_property_read_u8_array(np, propname, out_value, 1);
1187 : : }
1188 : :
1189 : : static inline int of_property_read_u16(const struct device_node *np,
1190 : : const char *propname,
1191 : : u16 *out_value)
1192 : : {
1193 : : return of_property_read_u16_array(np, propname, out_value, 1);
1194 : : }
1195 : :
1196 : : static inline int of_property_read_u32(const struct device_node *np,
1197 : : const char *propname,
1198 : : u32 *out_value)
1199 : : {
1200 : : return of_property_read_u32_array(np, propname, out_value, 1);
1201 : : }
1202 : :
1203 : : static inline int of_property_read_s32(const struct device_node *np,
1204 : : const char *propname,
1205 : : s32 *out_value)
1206 : : {
1207 : : return of_property_read_u32(np, propname, (u32*) out_value);
1208 : : }
1209 : :
1210 : : #define of_for_each_phandle(it, err, np, ln, cn, cc) \
1211 : : for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \
1212 : : err = of_phandle_iterator_next(it); \
1213 : : err == 0; \
1214 : : err = of_phandle_iterator_next(it))
1215 : :
1216 : : #define of_property_for_each_u32(np, propname, prop, p, u) \
1217 : : for (prop = of_find_property(np, propname, NULL), \
1218 : : p = of_prop_next_u32(prop, NULL, &u); \
1219 : : p; \
1220 : : p = of_prop_next_u32(prop, p, &u))
1221 : :
1222 : : #define of_property_for_each_string(np, propname, prop, s) \
1223 : : for (prop = of_find_property(np, propname, NULL), \
1224 : : s = of_prop_next_string(prop, NULL); \
1225 : : s; \
1226 : : s = of_prop_next_string(prop, s))
1227 : :
1228 : : #define for_each_node_by_name(dn, name) \
1229 : : for (dn = of_find_node_by_name(NULL, name); dn; \
1230 : : dn = of_find_node_by_name(dn, name))
1231 : : #define for_each_node_by_type(dn, type) \
1232 : : for (dn = of_find_node_by_type(NULL, type); dn; \
1233 : : dn = of_find_node_by_type(dn, type))
1234 : : #define for_each_compatible_node(dn, type, compatible) \
1235 : : for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
1236 : : dn = of_find_compatible_node(dn, type, compatible))
1237 : : #define for_each_matching_node(dn, matches) \
1238 : : for (dn = of_find_matching_node(NULL, matches); dn; \
1239 : : dn = of_find_matching_node(dn, matches))
1240 : : #define for_each_matching_node_and_match(dn, matches, match) \
1241 : : for (dn = of_find_matching_node_and_match(NULL, matches, match); \
1242 : : dn; dn = of_find_matching_node_and_match(dn, matches, match))
1243 : :
1244 : : #define for_each_child_of_node(parent, child) \
1245 : : for (child = of_get_next_child(parent, NULL); child != NULL; \
1246 : : child = of_get_next_child(parent, child))
1247 : : #define for_each_available_child_of_node(parent, child) \
1248 : : for (child = of_get_next_available_child(parent, NULL); child != NULL; \
1249 : : child = of_get_next_available_child(parent, child))
1250 : :
1251 : : #define for_each_of_cpu_node(cpu) \
1252 : : for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \
1253 : : cpu = of_get_next_cpu_node(cpu))
1254 : :
1255 : : #define for_each_node_with_property(dn, prop_name) \
1256 : : for (dn = of_find_node_with_property(NULL, prop_name); dn; \
1257 : : dn = of_find_node_with_property(dn, prop_name))
1258 : :
1259 : 0 : static inline int of_get_child_count(const struct device_node *np)
1260 : : {
1261 : : struct device_node *child;
1262 : : int num = 0;
1263 : :
1264 [ # # ]: 0 : for_each_child_of_node(np, child)
1265 : 0 : num++;
1266 : :
1267 : 0 : return num;
1268 : : }
1269 : :
1270 : : static inline int of_get_available_child_count(const struct device_node *np)
1271 : : {
1272 : : struct device_node *child;
1273 : : int num = 0;
1274 : :
1275 : : for_each_available_child_of_node(np, child)
1276 : : num++;
1277 : :
1278 : : return num;
1279 : : }
1280 : :
1281 : : #if defined(CONFIG_OF) && !defined(MODULE)
1282 : : #define _OF_DECLARE(table, name, compat, fn, fn_type) \
1283 : : static const struct of_device_id __of_table_##name \
1284 : : __used __section(__##table##_of_table) \
1285 : : = { .compatible = compat, \
1286 : : .data = (fn == (fn_type)NULL) ? fn : fn }
1287 : : #else
1288 : : #define _OF_DECLARE(table, name, compat, fn, fn_type) \
1289 : : static const struct of_device_id __of_table_##name \
1290 : : __attribute__((unused)) \
1291 : : = { .compatible = compat, \
1292 : : .data = (fn == (fn_type)NULL) ? fn : fn }
1293 : : #endif
1294 : :
1295 : : typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
1296 : : typedef int (*of_init_fn_1_ret)(struct device_node *);
1297 : : typedef void (*of_init_fn_1)(struct device_node *);
1298 : :
1299 : : #define OF_DECLARE_1(table, name, compat, fn) \
1300 : : _OF_DECLARE(table, name, compat, fn, of_init_fn_1)
1301 : : #define OF_DECLARE_1_RET(table, name, compat, fn) \
1302 : : _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret)
1303 : : #define OF_DECLARE_2(table, name, compat, fn) \
1304 : : _OF_DECLARE(table, name, compat, fn, of_init_fn_2)
1305 : :
1306 : : /**
1307 : : * struct of_changeset_entry - Holds a changeset entry
1308 : : *
1309 : : * @node: list_head for the log list
1310 : : * @action: notifier action
1311 : : * @np: pointer to the device node affected
1312 : : * @prop: pointer to the property affected
1313 : : * @old_prop: hold a pointer to the original property
1314 : : *
1315 : : * Every modification of the device tree during a changeset
1316 : : * is held in a list of of_changeset_entry structures.
1317 : : * That way we can recover from a partial application, or we can
1318 : : * revert the changeset
1319 : : */
1320 : : struct of_changeset_entry {
1321 : : struct list_head node;
1322 : : unsigned long action;
1323 : : struct device_node *np;
1324 : : struct property *prop;
1325 : : struct property *old_prop;
1326 : : };
1327 : :
1328 : : /**
1329 : : * struct of_changeset - changeset tracker structure
1330 : : *
1331 : : * @entries: list_head for the changeset entries
1332 : : *
1333 : : * changesets are a convenient way to apply bulk changes to the
1334 : : * live tree. In case of an error, changes are rolled-back.
1335 : : * changesets live on after initial application, and if not
1336 : : * destroyed after use, they can be reverted in one single call.
1337 : : */
1338 : : struct of_changeset {
1339 : : struct list_head entries;
1340 : : };
1341 : :
1342 : : enum of_reconfig_change {
1343 : : OF_RECONFIG_NO_CHANGE = 0,
1344 : : OF_RECONFIG_CHANGE_ADD,
1345 : : OF_RECONFIG_CHANGE_REMOVE,
1346 : : };
1347 : :
1348 : : #ifdef CONFIG_OF_DYNAMIC
1349 : : extern int of_reconfig_notifier_register(struct notifier_block *);
1350 : : extern int of_reconfig_notifier_unregister(struct notifier_block *);
1351 : : extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
1352 : : extern int of_reconfig_get_state_change(unsigned long action,
1353 : : struct of_reconfig_data *arg);
1354 : :
1355 : : extern void of_changeset_init(struct of_changeset *ocs);
1356 : : extern void of_changeset_destroy(struct of_changeset *ocs);
1357 : : extern int of_changeset_apply(struct of_changeset *ocs);
1358 : : extern int of_changeset_revert(struct of_changeset *ocs);
1359 : : extern int of_changeset_action(struct of_changeset *ocs,
1360 : : unsigned long action, struct device_node *np,
1361 : : struct property *prop);
1362 : :
1363 : : static inline int of_changeset_attach_node(struct of_changeset *ocs,
1364 : : struct device_node *np)
1365 : : {
1366 : 0 : return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
1367 : : }
1368 : :
1369 : : static inline int of_changeset_detach_node(struct of_changeset *ocs,
1370 : : struct device_node *np)
1371 : : {
1372 : : return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
1373 : : }
1374 : :
1375 : : static inline int of_changeset_add_property(struct of_changeset *ocs,
1376 : : struct device_node *np, struct property *prop)
1377 : : {
1378 : 0 : return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
1379 : : }
1380 : :
1381 : : static inline int of_changeset_remove_property(struct of_changeset *ocs,
1382 : : struct device_node *np, struct property *prop)
1383 : : {
1384 : : return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1385 : : }
1386 : :
1387 : : static inline int of_changeset_update_property(struct of_changeset *ocs,
1388 : : struct device_node *np, struct property *prop)
1389 : : {
1390 : 0 : return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
1391 : : }
1392 : : #else /* CONFIG_OF_DYNAMIC */
1393 : : static inline int of_reconfig_notifier_register(struct notifier_block *nb)
1394 : : {
1395 : : return -EINVAL;
1396 : : }
1397 : : static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
1398 : : {
1399 : : return -EINVAL;
1400 : : }
1401 : : static inline int of_reconfig_notify(unsigned long action,
1402 : : struct of_reconfig_data *arg)
1403 : : {
1404 : : return -EINVAL;
1405 : : }
1406 : : static inline int of_reconfig_get_state_change(unsigned long action,
1407 : : struct of_reconfig_data *arg)
1408 : : {
1409 : : return -EINVAL;
1410 : : }
1411 : : #endif /* CONFIG_OF_DYNAMIC */
1412 : :
1413 : : /**
1414 : : * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node
1415 : : * @np: Pointer to the given device_node
1416 : : *
1417 : : * return true if present false otherwise
1418 : : */
1419 : : static inline bool of_device_is_system_power_controller(const struct device_node *np)
1420 : : {
1421 : : return of_property_read_bool(np, "system-power-controller");
1422 : : }
1423 : :
1424 : : /**
1425 : : * Overlay support
1426 : : */
1427 : :
1428 : : enum of_overlay_notify_action {
1429 : : OF_OVERLAY_PRE_APPLY = 0,
1430 : : OF_OVERLAY_POST_APPLY,
1431 : : OF_OVERLAY_PRE_REMOVE,
1432 : : OF_OVERLAY_POST_REMOVE,
1433 : : };
1434 : :
1435 : : struct of_overlay_notify_data {
1436 : : struct device_node *overlay;
1437 : : struct device_node *target;
1438 : : };
1439 : :
1440 : : #ifdef CONFIG_OF_OVERLAY
1441 : :
1442 : : int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size,
1443 : : int *ovcs_id);
1444 : : int of_overlay_remove(int *ovcs_id);
1445 : : int of_overlay_remove_all(void);
1446 : :
1447 : : int of_overlay_notifier_register(struct notifier_block *nb);
1448 : : int of_overlay_notifier_unregister(struct notifier_block *nb);
1449 : :
1450 : : #else
1451 : :
1452 : : static inline int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size,
1453 : : int *ovcs_id)
1454 : : {
1455 : : return -ENOTSUPP;
1456 : : }
1457 : :
1458 : : static inline int of_overlay_remove(int *ovcs_id)
1459 : : {
1460 : : return -ENOTSUPP;
1461 : : }
1462 : :
1463 : : static inline int of_overlay_remove_all(void)
1464 : : {
1465 : : return -ENOTSUPP;
1466 : : }
1467 : :
1468 : : static inline int of_overlay_notifier_register(struct notifier_block *nb)
1469 : : {
1470 : : return 0;
1471 : : }
1472 : :
1473 : : static inline int of_overlay_notifier_unregister(struct notifier_block *nb)
1474 : : {
1475 : : return 0;
1476 : : }
1477 : :
1478 : : #endif
1479 : :
1480 : : #endif /* _LINUX_OF_H */
|
