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 : : kobject_init(&node->kobj, &of_node_ktype);
110 : : #endif
111 : : 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 : 210 : static inline struct device_node *of_node_get(struct device_node *node)
126 : : {
127 : 210 : 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_rid(struct device_node *np, u32 rid,
558 : : const char *map_name, const char *map_mask_name,
559 : : struct device_node **target, u32 *id_out);
560 : :
561 : : #else /* CONFIG_OF */
562 : :
563 : 21 : static inline void of_core_init(void)
564 : : {
565 : 21 : }
566 : :
567 : 0 : static inline bool is_of_node(const struct fwnode_handle *fwnode)
568 : : {
569 : 0 : return false;
570 : : }
571 : :
572 : 210 : static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode)
573 : : {
574 [ + + ]: 210 : return NULL;
575 : : }
576 : :
577 : : static inline bool of_node_name_eq(const struct device_node *np, const char *name)
578 : : {
579 : : return false;
580 : : }
581 : :
582 : : static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix)
583 : : {
584 : : return false;
585 : : }
586 : :
587 : 0 : static inline const char* of_node_full_name(const struct device_node *np)
588 : : {
589 : 0 : return "<no-node>";
590 : : }
591 : :
592 : : static inline struct device_node *of_find_node_by_name(struct device_node *from,
593 : : const char *name)
594 : : {
595 : : return NULL;
596 : : }
597 : :
598 : : static inline struct device_node *of_find_node_by_type(struct device_node *from,
599 : : const char *type)
600 : : {
601 : : return NULL;
602 : : }
603 : :
604 : 21 : static inline struct device_node *of_find_matching_node_and_match(
605 : : struct device_node *from,
606 : : const struct of_device_id *matches,
607 : : const struct of_device_id **match)
608 : : {
609 : 21 : return NULL;
610 : : }
611 : :
612 : : static inline struct device_node *of_find_node_by_path(const char *path)
613 : : {
614 : : return NULL;
615 : : }
616 : :
617 : : static inline struct device_node *of_find_node_opts_by_path(const char *path,
618 : : const char **opts)
619 : : {
620 : : return NULL;
621 : : }
622 : :
623 : : static inline struct device_node *of_find_node_by_phandle(phandle handle)
624 : : {
625 : : return NULL;
626 : : }
627 : :
628 : : static inline struct device_node *of_get_parent(const struct device_node *node)
629 : : {
630 : : return NULL;
631 : : }
632 : :
633 : 21 : static inline struct device_node *of_get_next_child(
634 : : const struct device_node *node, struct device_node *prev)
635 : : {
636 : 21 : return NULL;
637 : : }
638 : :
639 : 0 : static inline struct device_node *of_get_next_available_child(
640 : : const struct device_node *node, struct device_node *prev)
641 : : {
642 : 0 : return NULL;
643 : : }
644 : :
645 : : static inline struct device_node *of_find_node_with_property(
646 : : struct device_node *from, const char *prop_name)
647 : : {
648 : : return NULL;
649 : : }
650 : :
651 : : #define of_fwnode_handle(node) NULL
652 : :
653 : 0 : static inline bool of_have_populated_dt(void)
654 : : {
655 [ # # ]: 0 : return false;
656 : : }
657 : :
658 : : static inline struct device_node *of_get_compatible_child(const struct device_node *parent,
659 : : const char *compatible)
660 : : {
661 : : return NULL;
662 : : }
663 : :
664 : : static inline struct device_node *of_get_child_by_name(
665 : : const struct device_node *node,
666 : : const char *name)
667 : : {
668 : : return NULL;
669 : : }
670 : :
671 : 0 : static inline int of_device_is_compatible(const struct device_node *device,
672 : : const char *name)
673 : : {
674 : 0 : return 0;
675 : : }
676 : :
677 : : static inline int of_device_compatible_match(struct device_node *device,
678 : : const char *const *compat)
679 : : {
680 : : return 0;
681 : : }
682 : :
683 : 0 : static inline bool of_device_is_available(const struct device_node *device)
684 : : {
685 : 0 : return false;
686 : : }
687 : :
688 : : static inline bool of_device_is_big_endian(const struct device_node *device)
689 : : {
690 : : return false;
691 : : }
692 : :
693 : : static inline struct property *of_find_property(const struct device_node *np,
694 : : const char *name,
695 : : int *lenp)
696 : : {
697 : : return NULL;
698 : : }
699 : :
700 : 0 : static inline struct device_node *of_find_compatible_node(
701 : : struct device_node *from,
702 : : const char *type,
703 : : const char *compat)
704 : : {
705 : 0 : return NULL;
706 : : }
707 : :
708 : : static inline int of_property_count_elems_of_size(const struct device_node *np,
709 : : const char *propname, int elem_size)
710 : : {
711 : : return -ENOSYS;
712 : : }
713 : :
714 : : static inline int of_property_read_u8_array(const struct device_node *np,
715 : : const char *propname, u8 *out_values, size_t sz)
716 : : {
717 : : return -ENOSYS;
718 : : }
719 : :
720 : : static inline int of_property_read_u16_array(const struct device_node *np,
721 : : const char *propname, u16 *out_values, size_t sz)
722 : : {
723 : : return -ENOSYS;
724 : : }
725 : :
726 : : static inline int of_property_read_u32_array(const struct device_node *np,
727 : : const char *propname,
728 : : u32 *out_values, size_t sz)
729 : : {
730 : : return -ENOSYS;
731 : : }
732 : :
733 : : static inline int of_property_read_u64_array(const struct device_node *np,
734 : : const char *propname,
735 : : u64 *out_values, size_t sz)
736 : : {
737 : : return -ENOSYS;
738 : : }
739 : :
740 : : static inline int of_property_read_u32_index(const struct device_node *np,
741 : : const char *propname, u32 index, u32 *out_value)
742 : : {
743 : : return -ENOSYS;
744 : : }
745 : :
746 : : static inline int of_property_read_u64_index(const struct device_node *np,
747 : : const char *propname, u32 index, u64 *out_value)
748 : : {
749 : : return -ENOSYS;
750 : : }
751 : :
752 : 0 : static inline const void *of_get_property(const struct device_node *node,
753 : : const char *name,
754 : : int *lenp)
755 : : {
756 : 0 : return NULL;
757 : : }
758 : :
759 : 21 : static inline struct device_node *of_get_cpu_node(int cpu,
760 : : unsigned int *thread)
761 : : {
762 [ - + ]: 21 : return NULL;
763 : : }
764 : :
765 : : static inline struct device_node *of_get_next_cpu_node(struct device_node *prev)
766 : : {
767 : : return NULL;
768 : : }
769 : :
770 : : static inline struct device_node *of_get_cpu_state_node(struct device_node *cpu_node,
771 : : int index)
772 : : {
773 : : return NULL;
774 : : }
775 : :
776 : : static inline int of_n_addr_cells(struct device_node *np)
777 : : {
778 : : return 0;
779 : :
780 : : }
781 : : static inline int of_n_size_cells(struct device_node *np)
782 : : {
783 : : return 0;
784 : : }
785 : :
786 : : static inline int of_property_read_variable_u8_array(const struct device_node *np,
787 : : const char *propname, u8 *out_values,
788 : : size_t sz_min, size_t sz_max)
789 : : {
790 : : return -ENOSYS;
791 : : }
792 : :
793 : : static inline int of_property_read_variable_u16_array(const struct device_node *np,
794 : : const char *propname, u16 *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_u32_array(const struct device_node *np,
801 : : const char *propname,
802 : : u32 *out_values,
803 : : size_t sz_min,
804 : : size_t sz_max)
805 : : {
806 : : return -ENOSYS;
807 : : }
808 : :
809 : : static inline int of_property_read_u64(const struct device_node *np,
810 : : const char *propname, u64 *out_value)
811 : : {
812 : : return -ENOSYS;
813 : : }
814 : :
815 : : static inline int of_property_read_variable_u64_array(const struct device_node *np,
816 : : const char *propname,
817 : : u64 *out_values,
818 : : size_t sz_min,
819 : : size_t sz_max)
820 : : {
821 : : return -ENOSYS;
822 : : }
823 : :
824 : : static inline int of_property_read_string(const struct device_node *np,
825 : : const char *propname,
826 : : const char **out_string)
827 : : {
828 : : return -ENOSYS;
829 : : }
830 : :
831 : 0 : static inline int of_property_match_string(const struct device_node *np,
832 : : const char *propname,
833 : : const char *string)
834 : : {
835 [ # # # # ]: 0 : return -ENOSYS;
836 : : }
837 : :
838 : : static inline int of_property_read_string_helper(const struct device_node *np,
839 : : const char *propname,
840 : : const char **out_strs, size_t sz, int index)
841 : : {
842 : : return -ENOSYS;
843 : : }
844 : :
845 : 0 : static inline struct device_node *of_parse_phandle(const struct device_node *np,
846 : : const char *phandle_name,
847 : : int index)
848 : : {
849 [ # # ]: 0 : return NULL;
850 : : }
851 : :
852 : 0 : static inline int of_parse_phandle_with_args(const struct device_node *np,
853 : : const char *list_name,
854 : : const char *cells_name,
855 : : int index,
856 : : struct of_phandle_args *out_args)
857 : : {
858 [ # # # # ]: 0 : return -ENOSYS;
859 : : }
860 : :
861 : : static inline int of_parse_phandle_with_args_map(const struct device_node *np,
862 : : const char *list_name,
863 : : const char *stem_name,
864 : : int index,
865 : : struct of_phandle_args *out_args)
866 : : {
867 : : return -ENOSYS;
868 : : }
869 : :
870 : 0 : static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
871 : : const char *list_name, int cells_count, int index,
872 : : struct of_phandle_args *out_args)
873 : : {
874 : 0 : return -ENOSYS;
875 : : }
876 : :
877 : : static inline int of_count_phandle_with_args(struct device_node *np,
878 : : const char *list_name,
879 : : const char *cells_name)
880 : : {
881 : : return -ENOSYS;
882 : : }
883 : :
884 : : static inline int of_phandle_iterator_init(struct of_phandle_iterator *it,
885 : : const struct device_node *np,
886 : : const char *list_name,
887 : : const char *cells_name,
888 : : int cell_count)
889 : : {
890 : : return -ENOSYS;
891 : : }
892 : :
893 : : static inline int of_phandle_iterator_next(struct of_phandle_iterator *it)
894 : : {
895 : : return -ENOSYS;
896 : : }
897 : :
898 : : static inline int of_phandle_iterator_args(struct of_phandle_iterator *it,
899 : : uint32_t *args,
900 : : int size)
901 : : {
902 : : return 0;
903 : : }
904 : :
905 : : static inline int of_alias_get_id(struct device_node *np, const char *stem)
906 : : {
907 : : return -ENOSYS;
908 : : }
909 : :
910 : 21 : static inline int of_alias_get_highest_id(const char *stem)
911 : : {
912 : 21 : return -ENOSYS;
913 : : }
914 : :
915 : : static inline int of_alias_get_alias_list(const struct of_device_id *matches,
916 : : const char *stem, unsigned long *bitmap,
917 : : unsigned int nbits)
918 : : {
919 : : return -ENOSYS;
920 : : }
921 : :
922 : : static inline int of_machine_is_compatible(const char *compat)
923 : : {
924 : : return 0;
925 : : }
926 : :
927 : : static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
928 : : {
929 : : return false;
930 : : }
931 : :
932 : : static inline const __be32 *of_prop_next_u32(struct property *prop,
933 : : const __be32 *cur, u32 *pu)
934 : : {
935 : : return NULL;
936 : : }
937 : :
938 : : static inline const char *of_prop_next_string(struct property *prop,
939 : : const char *cur)
940 : : {
941 : : return NULL;
942 : : }
943 : :
944 : : static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
945 : : {
946 : : return 0;
947 : : }
948 : :
949 : : static inline int of_node_test_and_set_flag(struct device_node *n,
950 : : unsigned long flag)
951 : : {
952 : : return 0;
953 : : }
954 : :
955 : : static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
956 : : {
957 : : }
958 : :
959 : : static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
960 : : {
961 : : }
962 : :
963 : : static inline int of_property_check_flag(struct property *p, unsigned long flag)
964 : : {
965 : : return 0;
966 : : }
967 : :
968 : : static inline void of_property_set_flag(struct property *p, unsigned long flag)
969 : : {
970 : : }
971 : :
972 : : static inline void of_property_clear_flag(struct property *p, unsigned long flag)
973 : : {
974 : : }
975 : :
976 : : static inline int of_cpu_node_to_id(struct device_node *np)
977 : : {
978 : : return -ENODEV;
979 : : }
980 : :
981 : : static inline int of_map_rid(struct device_node *np, u32 rid,
982 : : const char *map_name, const char *map_mask_name,
983 : : struct device_node **target, u32 *id_out)
984 : : {
985 : : return -EINVAL;
986 : : }
987 : :
988 : : #define of_match_ptr(_ptr) NULL
989 : : #define of_match_node(_matches, _node) NULL
990 : : #endif /* CONFIG_OF */
991 : :
992 : : /* Default string compare functions, Allow arch asm/prom.h to override */
993 : : #if !defined(of_compat_cmp)
994 : : #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
995 : : #define of_prop_cmp(s1, s2) strcmp((s1), (s2))
996 : : #define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
997 : : #endif
998 : :
999 : : static inline int of_prop_val_eq(struct property *p1, struct property *p2)
1000 : : {
1001 : : return p1->length == p2->length &&
1002 : : !memcmp(p1->value, p2->value, (size_t)p1->length);
1003 : : }
1004 : :
1005 : : #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
1006 : : extern int of_node_to_nid(struct device_node *np);
1007 : : #else
1008 : 84 : static inline int of_node_to_nid(struct device_node *device)
1009 : : {
1010 : 84 : return NUMA_NO_NODE;
1011 : : }
1012 : : #endif
1013 : :
1014 : : #ifdef CONFIG_OF_NUMA
1015 : : extern int of_numa_init(void);
1016 : : #else
1017 : : static inline int of_numa_init(void)
1018 : : {
1019 : : return -ENOSYS;
1020 : : }
1021 : : #endif
1022 : :
1023 : 21 : static inline struct device_node *of_find_matching_node(
1024 : : struct device_node *from,
1025 : : const struct of_device_id *matches)
1026 : : {
1027 : 21 : return of_find_matching_node_and_match(from, matches, NULL);
1028 : : }
1029 : :
1030 : : static inline const char *of_node_get_device_type(const struct device_node *np)
1031 : : {
1032 : : return of_get_property(np, "device_type", NULL);
1033 : : }
1034 : :
1035 : : static inline bool of_node_is_type(const struct device_node *np, const char *type)
1036 : : {
1037 : : const char *match = of_node_get_device_type(np);
1038 : :
1039 : : return np && match && type && !strcmp(match, type);
1040 : : }
1041 : :
1042 : : /**
1043 : : * of_property_count_u8_elems - Count the number of u8 elements in a property
1044 : : *
1045 : : * @np: device node from which the property value is to be read.
1046 : : * @propname: name of the property to be searched.
1047 : : *
1048 : : * Search for a property in a device node and count the number of u8 elements
1049 : : * in it. Returns number of elements on sucess, -EINVAL if the property does
1050 : : * not exist or its length does not match a multiple of u8 and -ENODATA if the
1051 : : * property does not have a value.
1052 : : */
1053 : : static inline int of_property_count_u8_elems(const struct device_node *np,
1054 : : const char *propname)
1055 : : {
1056 : : return of_property_count_elems_of_size(np, propname, sizeof(u8));
1057 : : }
1058 : :
1059 : : /**
1060 : : * of_property_count_u16_elems - Count the number of u16 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 u16 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 u16 and -ENODATA if the
1068 : : * property does not have a value.
1069 : : */
1070 : : static inline int of_property_count_u16_elems(const struct device_node *np,
1071 : : const char *propname)
1072 : : {
1073 : : return of_property_count_elems_of_size(np, propname, sizeof(u16));
1074 : : }
1075 : :
1076 : : /**
1077 : : * of_property_count_u32_elems - Count the number of u32 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 u32 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 u32 and -ENODATA if the
1085 : : * property does not have a value.
1086 : : */
1087 : : static inline int of_property_count_u32_elems(const struct device_node *np,
1088 : : const char *propname)
1089 : : {
1090 : : return of_property_count_elems_of_size(np, propname, sizeof(u32));
1091 : : }
1092 : :
1093 : : /**
1094 : : * of_property_count_u64_elems - Count the number of u64 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 u64 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 u64 and -ENODATA if the
1102 : : * property does not have a value.
1103 : : */
1104 : : static inline int of_property_count_u64_elems(const struct device_node *np,
1105 : : const char *propname)
1106 : : {
1107 : : return of_property_count_elems_of_size(np, propname, sizeof(u64));
1108 : : }
1109 : :
1110 : : /**
1111 : : * of_property_read_string_array() - Read an array of strings from a multiple
1112 : : * strings property.
1113 : : * @np: device node from which the property value is to be read.
1114 : : * @propname: name of the property to be searched.
1115 : : * @out_strs: output array of string pointers.
1116 : : * @sz: number of array elements to read.
1117 : : *
1118 : : * Search for a property in a device tree node and retrieve a list of
1119 : : * terminated string values (pointer to data, not a copy) in that property.
1120 : : *
1121 : : * If @out_strs is NULL, the number of strings in the property is returned.
1122 : : */
1123 : : static inline int of_property_read_string_array(const struct device_node *np,
1124 : : const char *propname, const char **out_strs,
1125 : : size_t sz)
1126 : : {
1127 : : return of_property_read_string_helper(np, propname, out_strs, sz, 0);
1128 : : }
1129 : :
1130 : : /**
1131 : : * of_property_count_strings() - Find and return the number of strings from a
1132 : : * multiple strings property.
1133 : : * @np: device node from which the property value is to be read.
1134 : : * @propname: name of the property to be searched.
1135 : : *
1136 : : * Search for a property in a device tree node and retrieve the number of null
1137 : : * terminated string contain in it. Returns the number of strings on
1138 : : * success, -EINVAL if the property does not exist, -ENODATA if property
1139 : : * does not have a value, and -EILSEQ if the string is not null-terminated
1140 : : * within the length of the property data.
1141 : : */
1142 : : static inline int of_property_count_strings(const struct device_node *np,
1143 : : const char *propname)
1144 : : {
1145 : : return of_property_read_string_helper(np, propname, NULL, 0, 0);
1146 : : }
1147 : :
1148 : : /**
1149 : : * of_property_read_string_index() - Find and read a string from a multiple
1150 : : * strings property.
1151 : : * @np: device node from which the property value is to be read.
1152 : : * @propname: name of the property to be searched.
1153 : : * @index: index of the string in the list of strings
1154 : : * @out_string: pointer to null terminated return string, modified only if
1155 : : * return value is 0.
1156 : : *
1157 : : * Search for a property in a device tree node and retrieve a null
1158 : : * terminated string value (pointer to data, not a copy) in the list of strings
1159 : : * contained in that property.
1160 : : * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
1161 : : * property does not have a value, and -EILSEQ if the string is not
1162 : : * null-terminated within the length of the property data.
1163 : : *
1164 : : * The out_string pointer is modified only if a valid string can be decoded.
1165 : : */
1166 : : static inline int of_property_read_string_index(const struct device_node *np,
1167 : : const char *propname,
1168 : : int index, const char **output)
1169 : : {
1170 : : int rc = of_property_read_string_helper(np, propname, output, 1, index);
1171 : : return rc < 0 ? rc : 0;
1172 : : }
1173 : :
1174 : : /**
1175 : : * of_property_read_bool - Find a property
1176 : : * @np: device node from which the property value is to be read.
1177 : : * @propname: name of the property to be searched.
1178 : : *
1179 : : * Search for a property in a device node.
1180 : : * Returns true if the property exists false otherwise.
1181 : : */
1182 : : static inline bool of_property_read_bool(const struct device_node *np,
1183 : : const char *propname)
1184 : : {
1185 : : struct property *prop = of_find_property(np, propname, NULL);
1186 : :
1187 : : return prop ? true : false;
1188 : : }
1189 : :
1190 : : static inline int of_property_read_u8(const struct device_node *np,
1191 : : const char *propname,
1192 : : u8 *out_value)
1193 : : {
1194 : : return of_property_read_u8_array(np, propname, out_value, 1);
1195 : : }
1196 : :
1197 : : static inline int of_property_read_u16(const struct device_node *np,
1198 : : const char *propname,
1199 : : u16 *out_value)
1200 : : {
1201 : : return of_property_read_u16_array(np, propname, out_value, 1);
1202 : : }
1203 : :
1204 : : static inline int of_property_read_u32(const struct device_node *np,
1205 : : const char *propname,
1206 : : u32 *out_value)
1207 : : {
1208 : : return of_property_read_u32_array(np, propname, out_value, 1);
1209 : : }
1210 : :
1211 : : static inline int of_property_read_s32(const struct device_node *np,
1212 : : const char *propname,
1213 : : s32 *out_value)
1214 : : {
1215 : : return of_property_read_u32(np, propname, (u32*) out_value);
1216 : : }
1217 : :
1218 : : #define of_for_each_phandle(it, err, np, ln, cn, cc) \
1219 : : for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \
1220 : : err = of_phandle_iterator_next(it); \
1221 : : err == 0; \
1222 : : err = of_phandle_iterator_next(it))
1223 : :
1224 : : #define of_property_for_each_u32(np, propname, prop, p, u) \
1225 : : for (prop = of_find_property(np, propname, NULL), \
1226 : : p = of_prop_next_u32(prop, NULL, &u); \
1227 : : p; \
1228 : : p = of_prop_next_u32(prop, p, &u))
1229 : :
1230 : : #define of_property_for_each_string(np, propname, prop, s) \
1231 : : for (prop = of_find_property(np, propname, NULL), \
1232 : : s = of_prop_next_string(prop, NULL); \
1233 : : s; \
1234 : : s = of_prop_next_string(prop, s))
1235 : :
1236 : : #define for_each_node_by_name(dn, name) \
1237 : : for (dn = of_find_node_by_name(NULL, name); dn; \
1238 : : dn = of_find_node_by_name(dn, name))
1239 : : #define for_each_node_by_type(dn, type) \
1240 : : for (dn = of_find_node_by_type(NULL, type); dn; \
1241 : : dn = of_find_node_by_type(dn, type))
1242 : : #define for_each_compatible_node(dn, type, compatible) \
1243 : : for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
1244 : : dn = of_find_compatible_node(dn, type, compatible))
1245 : : #define for_each_matching_node(dn, matches) \
1246 : : for (dn = of_find_matching_node(NULL, matches); dn; \
1247 : : dn = of_find_matching_node(dn, matches))
1248 : : #define for_each_matching_node_and_match(dn, matches, match) \
1249 : : for (dn = of_find_matching_node_and_match(NULL, matches, match); \
1250 : : dn; dn = of_find_matching_node_and_match(dn, matches, match))
1251 : :
1252 : : #define for_each_child_of_node(parent, child) \
1253 : : for (child = of_get_next_child(parent, NULL); child != NULL; \
1254 : : child = of_get_next_child(parent, child))
1255 : : #define for_each_available_child_of_node(parent, child) \
1256 : : for (child = of_get_next_available_child(parent, NULL); child != NULL; \
1257 : : child = of_get_next_available_child(parent, child))
1258 : :
1259 : : #define for_each_of_cpu_node(cpu) \
1260 : : for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \
1261 : : cpu = of_get_next_cpu_node(cpu))
1262 : :
1263 : : #define for_each_node_with_property(dn, prop_name) \
1264 : : for (dn = of_find_node_with_property(NULL, prop_name); dn; \
1265 : : dn = of_find_node_with_property(dn, prop_name))
1266 : :
1267 : : static inline int of_get_child_count(const struct device_node *np)
1268 : : {
1269 : : struct device_node *child;
1270 : : int num = 0;
1271 : :
1272 : : for_each_child_of_node(np, child)
1273 : : num++;
1274 : :
1275 : : return num;
1276 : : }
1277 : :
1278 : : static inline int of_get_available_child_count(const struct device_node *np)
1279 : : {
1280 : : struct device_node *child;
1281 : : int num = 0;
1282 : :
1283 : : for_each_available_child_of_node(np, child)
1284 : : num++;
1285 : :
1286 : : return num;
1287 : : }
1288 : :
1289 : : #if defined(CONFIG_OF) && !defined(MODULE)
1290 : : #define _OF_DECLARE(table, name, compat, fn, fn_type) \
1291 : : static const struct of_device_id __of_table_##name \
1292 : : __used __section(__##table##_of_table) \
1293 : : = { .compatible = compat, \
1294 : : .data = (fn == (fn_type)NULL) ? fn : fn }
1295 : : #else
1296 : : #define _OF_DECLARE(table, name, compat, fn, fn_type) \
1297 : : static const struct of_device_id __of_table_##name \
1298 : : __attribute__((unused)) \
1299 : : = { .compatible = compat, \
1300 : : .data = (fn == (fn_type)NULL) ? fn : fn }
1301 : : #endif
1302 : :
1303 : : typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
1304 : : typedef int (*of_init_fn_1_ret)(struct device_node *);
1305 : : typedef void (*of_init_fn_1)(struct device_node *);
1306 : :
1307 : : #define OF_DECLARE_1(table, name, compat, fn) \
1308 : : _OF_DECLARE(table, name, compat, fn, of_init_fn_1)
1309 : : #define OF_DECLARE_1_RET(table, name, compat, fn) \
1310 : : _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret)
1311 : : #define OF_DECLARE_2(table, name, compat, fn) \
1312 : : _OF_DECLARE(table, name, compat, fn, of_init_fn_2)
1313 : :
1314 : : /**
1315 : : * struct of_changeset_entry - Holds a changeset entry
1316 : : *
1317 : : * @node: list_head for the log list
1318 : : * @action: notifier action
1319 : : * @np: pointer to the device node affected
1320 : : * @prop: pointer to the property affected
1321 : : * @old_prop: hold a pointer to the original property
1322 : : *
1323 : : * Every modification of the device tree during a changeset
1324 : : * is held in a list of of_changeset_entry structures.
1325 : : * That way we can recover from a partial application, or we can
1326 : : * revert the changeset
1327 : : */
1328 : : struct of_changeset_entry {
1329 : : struct list_head node;
1330 : : unsigned long action;
1331 : : struct device_node *np;
1332 : : struct property *prop;
1333 : : struct property *old_prop;
1334 : : };
1335 : :
1336 : : /**
1337 : : * struct of_changeset - changeset tracker structure
1338 : : *
1339 : : * @entries: list_head for the changeset entries
1340 : : *
1341 : : * changesets are a convenient way to apply bulk changes to the
1342 : : * live tree. In case of an error, changes are rolled-back.
1343 : : * changesets live on after initial application, and if not
1344 : : * destroyed after use, they can be reverted in one single call.
1345 : : */
1346 : : struct of_changeset {
1347 : : struct list_head entries;
1348 : : };
1349 : :
1350 : : enum of_reconfig_change {
1351 : : OF_RECONFIG_NO_CHANGE = 0,
1352 : : OF_RECONFIG_CHANGE_ADD,
1353 : : OF_RECONFIG_CHANGE_REMOVE,
1354 : : };
1355 : :
1356 : : #ifdef CONFIG_OF_DYNAMIC
1357 : : extern int of_reconfig_notifier_register(struct notifier_block *);
1358 : : extern int of_reconfig_notifier_unregister(struct notifier_block *);
1359 : : extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
1360 : : extern int of_reconfig_get_state_change(unsigned long action,
1361 : : struct of_reconfig_data *arg);
1362 : :
1363 : : extern void of_changeset_init(struct of_changeset *ocs);
1364 : : extern void of_changeset_destroy(struct of_changeset *ocs);
1365 : : extern int of_changeset_apply(struct of_changeset *ocs);
1366 : : extern int of_changeset_revert(struct of_changeset *ocs);
1367 : : extern int of_changeset_action(struct of_changeset *ocs,
1368 : : unsigned long action, struct device_node *np,
1369 : : struct property *prop);
1370 : :
1371 : : static inline int of_changeset_attach_node(struct of_changeset *ocs,
1372 : : struct device_node *np)
1373 : : {
1374 : : return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
1375 : : }
1376 : :
1377 : : static inline int of_changeset_detach_node(struct of_changeset *ocs,
1378 : : struct device_node *np)
1379 : : {
1380 : : return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
1381 : : }
1382 : :
1383 : : static inline int of_changeset_add_property(struct of_changeset *ocs,
1384 : : struct device_node *np, struct property *prop)
1385 : : {
1386 : : return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
1387 : : }
1388 : :
1389 : : static inline int of_changeset_remove_property(struct of_changeset *ocs,
1390 : : struct device_node *np, struct property *prop)
1391 : : {
1392 : : return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1393 : : }
1394 : :
1395 : : static inline int of_changeset_update_property(struct of_changeset *ocs,
1396 : : struct device_node *np, struct property *prop)
1397 : : {
1398 : : return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
1399 : : }
1400 : : #else /* CONFIG_OF_DYNAMIC */
1401 : : static inline int of_reconfig_notifier_register(struct notifier_block *nb)
1402 : : {
1403 : : return -EINVAL;
1404 : : }
1405 : : static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
1406 : : {
1407 : : return -EINVAL;
1408 : : }
1409 : : static inline int of_reconfig_notify(unsigned long action,
1410 : : struct of_reconfig_data *arg)
1411 : : {
1412 : : return -EINVAL;
1413 : : }
1414 : : static inline int of_reconfig_get_state_change(unsigned long action,
1415 : : struct of_reconfig_data *arg)
1416 : : {
1417 : : return -EINVAL;
1418 : : }
1419 : : #endif /* CONFIG_OF_DYNAMIC */
1420 : :
1421 : : /**
1422 : : * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node
1423 : : * @np: Pointer to the given device_node
1424 : : *
1425 : : * return true if present false otherwise
1426 : : */
1427 : : static inline bool of_device_is_system_power_controller(const struct device_node *np)
1428 : : {
1429 : : return of_property_read_bool(np, "system-power-controller");
1430 : : }
1431 : :
1432 : : /**
1433 : : * Overlay support
1434 : : */
1435 : :
1436 : : enum of_overlay_notify_action {
1437 : : OF_OVERLAY_PRE_APPLY = 0,
1438 : : OF_OVERLAY_POST_APPLY,
1439 : : OF_OVERLAY_PRE_REMOVE,
1440 : : OF_OVERLAY_POST_REMOVE,
1441 : : };
1442 : :
1443 : : struct of_overlay_notify_data {
1444 : : struct device_node *overlay;
1445 : : struct device_node *target;
1446 : : };
1447 : :
1448 : : #ifdef CONFIG_OF_OVERLAY
1449 : :
1450 : : int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size,
1451 : : int *ovcs_id);
1452 : : int of_overlay_remove(int *ovcs_id);
1453 : : int of_overlay_remove_all(void);
1454 : :
1455 : : int of_overlay_notifier_register(struct notifier_block *nb);
1456 : : int of_overlay_notifier_unregister(struct notifier_block *nb);
1457 : :
1458 : : #else
1459 : :
1460 : : static inline int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size,
1461 : : int *ovcs_id)
1462 : : {
1463 : : return -ENOTSUPP;
1464 : : }
1465 : :
1466 : : static inline int of_overlay_remove(int *ovcs_id)
1467 : : {
1468 : : return -ENOTSUPP;
1469 : : }
1470 : :
1471 : : static inline int of_overlay_remove_all(void)
1472 : : {
1473 : : return -ENOTSUPP;
1474 : : }
1475 : :
1476 : : static inline int of_overlay_notifier_register(struct notifier_block *nb)
1477 : : {
1478 : : return 0;
1479 : : }
1480 : :
1481 : : static inline int of_overlay_notifier_unregister(struct notifier_block *nb)
1482 : : {
1483 : : return 0;
1484 : : }
1485 : :
1486 : : #endif
1487 : :
1488 : : #endif /* _LINUX_OF_H */
|
