1
2#ifndef _LINUX_OF_H
3#define _LINUX_OF_H
4
5
6
7
8
9
10
11
12
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
28typedef u32 phandle;
29typedef u32 ihandle;
30
31struct 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)
48struct of_irq_controller;
49#endif
50
51struct 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;
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
74struct of_phandle_args {
75 struct device_node *np;
76 int args_count;
77 uint32_t args[MAX_PHANDLE_ARGS];
78};
79
80struct of_phandle_iterator {
81
82 const char *cells_name;
83 int cell_count;
84 const struct device_node *parent;
85
86
87 const __be32 *list_end;
88 const __be32 *phandle_end;
89
90
91 const __be32 *cur;
92 uint32_t cur_count;
93 phandle phandle;
94 struct device_node *node;
95};
96
97struct of_reconfig_data {
98 struct device_node *dn;
99 struct property *prop;
100 struct property *old_prop;
101};
102
103
104extern struct kobj_type of_node_ktype;
105extern const struct fwnode_operations of_fwnode_ops;
106static inline void of_node_init(struct device_node *node)
107{
108#if defined(CONFIG_OF_KOBJ)
109 kobject_init(&node->kobj, &of_node_ktype);
110#endif
111 fwnode_init(&node->fwnode, &of_fwnode_ops);
112}
113
114#if defined(CONFIG_OF_KOBJ)
115#define of_node_kobj(n) (&(n)->kobj)
116#else
117#define of_node_kobj(n) NULL
118#endif
119
120#ifdef CONFIG_OF_DYNAMIC
121extern struct device_node *of_node_get(struct device_node *node);
122extern void of_node_put(struct device_node *node);
123#else
124
125static inline struct device_node *of_node_get(struct device_node *node)
126{
127 return node;
128}
129static inline void of_node_put(struct device_node *node) { }
130#endif
131
132
133extern struct device_node *of_root;
134extern struct device_node *of_chosen;
135extern struct device_node *of_aliases;
136extern struct device_node *of_stdout;
137extern raw_spinlock_t devtree_lock;
138
139
140
141
142
143#define OF_DYNAMIC 1
144#define OF_DETACHED 2
145#define OF_POPULATED 3
146#define OF_POPULATED_BUS 4
147#define OF_OVERLAY 5
148#define OF_OVERLAY_FREE_CSET 6
149
150#define OF_BAD_ADDR ((u64)-1)
151
152#ifdef CONFIG_OF
153void of_core_init(void);
154
155static 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
178static inline bool of_have_populated_dt(void)
179{
180 return of_root != NULL;
181}
182
183static inline bool of_node_is_root(const struct device_node *node)
184{
185 return node && (node->parent == NULL);
186}
187
188static inline int of_node_check_flag(const struct device_node *n, unsigned long flag)
189{
190 return test_bit(flag, &n->_flags);
191}
192
193static 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
199static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
200{
201 set_bit(flag, &n->_flags);
202}
203
204static 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)
210static inline int of_property_check_flag(struct property *p, unsigned long flag)
211{
212 return test_bit(flag, &p->_flags);
213}
214
215static inline void of_property_set_flag(struct property *p, unsigned long flag)
216{
217 set_bit(flag, &p->_flags);
218}
219
220static inline void of_property_clear_flag(struct property *p, unsigned long flag)
221{
222 clear_bit(flag, &p->_flags);
223}
224#endif
225
226extern struct device_node *__of_find_all_nodes(struct device_node *prev);
227extern struct device_node *of_find_all_nodes(struct device_node *prev);
228
229
230
231
232
233
234static 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
243static inline unsigned long of_read_ulong(const __be32 *cell, int size)
244{
245
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
256extern bool of_node_name_eq(const struct device_node *np, const char *name);
257extern bool of_node_name_prefix(const struct device_node *np, const char *prefix);
258
259static 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)
267extern struct device_node *of_find_node_by_name(struct device_node *from,
268 const char *name);
269extern struct device_node *of_find_node_by_type(struct device_node *from,
270 const char *type);
271extern struct device_node *of_find_compatible_node(struct device_node *from,
272 const char *type, const char *compat);
273extern 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
278extern struct device_node *of_find_node_opts_by_path(const char *path,
279 const char **opts);
280static 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
285extern struct device_node *of_find_node_by_phandle(phandle handle);
286extern struct device_node *of_get_parent(const struct device_node *node);
287extern struct device_node *of_get_next_parent(struct device_node *node);
288extern struct device_node *of_get_next_child(const struct device_node *node,
289 struct device_node *prev);
290extern struct device_node *of_get_next_available_child(
291 const struct device_node *node, struct device_node *prev);
292
293extern struct device_node *of_get_compatible_child(const struct device_node *parent,
294 const char *compatible);
295extern struct device_node *of_get_child_by_name(const struct device_node *node,
296 const char *name);
297
298
299extern struct device_node *of_find_next_cache_node(const struct device_node *);
300extern int of_find_last_cache_level(unsigned int cpu);
301extern struct device_node *of_find_node_with_property(
302 struct device_node *from, const char *prop_name);
303
304extern struct property *of_find_property(const struct device_node *np,
305 const char *name,
306 int *lenp);
307extern int of_property_count_elems_of_size(const struct device_node *np,
308 const char *propname, int elem_size);
309extern int of_property_read_u32_index(const struct device_node *np,
310 const char *propname,
311 u32 index, u32 *out_value);
312extern int of_property_read_u64_index(const struct device_node *np,
313 const char *propname,
314 u32 index, u64 *out_value);
315extern 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);
318extern 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);
321extern 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);
326extern int of_property_read_u64(const struct device_node *np,
327 const char *propname, u64 *out_value);
328extern 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
334extern int of_property_read_string(const struct device_node *np,
335 const char *propname,
336 const char **out_string);
337extern int of_property_match_string(const struct device_node *np,
338 const char *propname,
339 const char *string);
340extern 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);
343extern int of_device_is_compatible(const struct device_node *device,
344 const char *);
345extern int of_device_compatible_match(struct device_node *device,
346 const char *const *compat);
347extern bool of_device_is_available(const struct device_node *device);
348extern bool of_device_is_big_endian(const struct device_node *device);
349extern const void *of_get_property(const struct device_node *node,
350 const char *name,
351 int *lenp);
352extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
353extern struct device_node *of_get_next_cpu_node(struct device_node *prev);
354extern struct device_node *of_get_cpu_state_node(struct device_node *cpu_node,
355 int index);
356extern u64 of_get_cpu_hwid(struct device_node *cpun, unsigned int thread);
357
358#define for_each_property_of_node(dn, pp) \
359 for (pp = dn->properties; pp != NULL; pp = pp->next)
360
361extern int of_n_addr_cells(struct device_node *np);
362extern int of_n_size_cells(struct device_node *np);
363extern const struct of_device_id *of_match_node(
364 const struct of_device_id *matches, const struct device_node *node);
365extern int of_modalias_node(struct device_node *node, char *modalias, int len);
366extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
367extern int __of_parse_phandle_with_args(const struct device_node *np,
368 const char *list_name, const char *cells_name, int cell_count,
369 int index, struct of_phandle_args *out_args);
370extern 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);
373extern int of_count_phandle_with_args(const struct device_node *np,
374 const char *list_name, const char *cells_name);
375
376
377extern int of_phandle_iterator_init(struct of_phandle_iterator *it,
378 const struct device_node *np,
379 const char *list_name,
380 const char *cells_name,
381 int cell_count);
382
383extern int of_phandle_iterator_next(struct of_phandle_iterator *it);
384extern int of_phandle_iterator_args(struct of_phandle_iterator *it,
385 uint32_t *args,
386 int size);
387
388extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
389extern int of_alias_get_id(struct device_node *np, const char *stem);
390extern int of_alias_get_highest_id(const char *stem);
391extern int of_alias_get_alias_list(const struct of_device_id *matches,
392 const char *stem, unsigned long *bitmap,
393 unsigned int nbits);
394
395extern int of_machine_is_compatible(const char *compat);
396
397extern int of_add_property(struct device_node *np, struct property *prop);
398extern int of_remove_property(struct device_node *np, struct property *prop);
399extern int of_update_property(struct device_node *np, struct property *newprop);
400
401
402#define OF_RECONFIG_ATTACH_NODE 0x0001
403#define OF_RECONFIG_DETACH_NODE 0x0002
404#define OF_RECONFIG_ADD_PROPERTY 0x0003
405#define OF_RECONFIG_REMOVE_PROPERTY 0x0004
406#define OF_RECONFIG_UPDATE_PROPERTY 0x0005
407
408extern int of_attach_node(struct device_node *);
409extern int of_detach_node(struct device_node *);
410
411#define of_match_ptr(_ptr) (_ptr)
412
413
414
415
416
417
418
419
420
421const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
422 u32 *pu);
423
424
425
426
427
428
429
430const char *of_prop_next_string(struct property *prop, const char *cur);
431
432bool of_console_check(struct device_node *dn, char *name, int index);
433
434extern int of_cpu_node_to_id(struct device_node *np);
435
436int of_map_id(struct device_node *np, u32 id,
437 const char *map_name, const char *map_mask_name,
438 struct device_node **target, u32 *id_out);
439
440phys_addr_t of_dma_get_max_cpu_address(struct device_node *np);
441
442struct kimage;
443void *of_kexec_alloc_and_setup_fdt(const struct kimage *image,
444 unsigned long initrd_load_addr,
445 unsigned long initrd_len,
446 const char *cmdline, size_t extra_fdt_size);
447int ima_get_kexec_buffer(void **addr, size_t *size);
448int ima_free_kexec_buffer(void);
449#else
450
451static inline void of_core_init(void)
452{
453}
454
455static inline bool is_of_node(const struct fwnode_handle *fwnode)
456{
457 return false;
458}
459
460static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode)
461{
462 return NULL;
463}
464
465static inline bool of_node_name_eq(const struct device_node *np, const char *name)
466{
467 return false;
468}
469
470static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix)
471{
472 return false;
473}
474
475static inline const char* of_node_full_name(const struct device_node *np)
476{
477 return "<no-node>";
478}
479
480static inline struct device_node *of_find_node_by_name(struct device_node *from,
481 const char *name)
482{
483 return NULL;
484}
485
486static inline struct device_node *of_find_node_by_type(struct device_node *from,
487 const char *type)
488{
489 return NULL;
490}
491
492static inline struct device_node *of_find_matching_node_and_match(
493 struct device_node *from,
494 const struct of_device_id *matches,
495 const struct of_device_id **match)
496{
497 return NULL;
498}
499
500static inline struct device_node *of_find_node_by_path(const char *path)
501{
502 return NULL;
503}
504
505static inline struct device_node *of_find_node_opts_by_path(const char *path,
506 const char **opts)
507{
508 return NULL;
509}
510
511static inline struct device_node *of_find_node_by_phandle(phandle handle)
512{
513 return NULL;
514}
515
516static inline struct device_node *of_get_parent(const struct device_node *node)
517{
518 return NULL;
519}
520
521static inline struct device_node *of_get_next_parent(struct device_node *node)
522{
523 return NULL;
524}
525
526static inline struct device_node *of_get_next_child(
527 const struct device_node *node, struct device_node *prev)
528{
529 return NULL;
530}
531
532static inline struct device_node *of_get_next_available_child(
533 const struct device_node *node, struct device_node *prev)
534{
535 return NULL;
536}
537
538static inline struct device_node *of_find_node_with_property(
539 struct device_node *from, const char *prop_name)
540{
541 return NULL;
542}
543
544#define of_fwnode_handle(node) NULL
545
546static inline bool of_have_populated_dt(void)
547{
548 return false;
549}
550
551static inline struct device_node *of_get_compatible_child(const struct device_node *parent,
552 const char *compatible)
553{
554 return NULL;
555}
556
557static inline struct device_node *of_get_child_by_name(
558 const struct device_node *node,
559 const char *name)
560{
561 return NULL;
562}
563
564static inline int of_device_is_compatible(const struct device_node *device,
565 const char *name)
566{
567 return 0;
568}
569
570static inline int of_device_compatible_match(struct device_node *device,
571 const char *const *compat)
572{
573 return 0;
574}
575
576static inline bool of_device_is_available(const struct device_node *device)
577{
578 return false;
579}
580
581static inline bool of_device_is_big_endian(const struct device_node *device)
582{
583 return false;
584}
585
586static inline struct property *of_find_property(const struct device_node *np,
587 const char *name,
588 int *lenp)
589{
590 return NULL;
591}
592
593static inline struct device_node *of_find_compatible_node(
594 struct device_node *from,
595 const char *type,
596 const char *compat)
597{
598 return NULL;
599}
600
601static inline int of_property_count_elems_of_size(const struct device_node *np,
602 const char *propname, int elem_size)
603{
604 return -ENOSYS;
605}
606
607static inline int of_property_read_u32_index(const struct device_node *np,
608 const char *propname, u32 index, u32 *out_value)
609{
610 return -ENOSYS;
611}
612
613static inline int of_property_read_u64_index(const struct device_node *np,
614 const char *propname, u32 index, u64 *out_value)
615{
616 return -ENOSYS;
617}
618
619static inline const void *of_get_property(const struct device_node *node,
620 const char *name,
621 int *lenp)
622{
623 return NULL;
624}
625
626static inline struct device_node *of_get_cpu_node(int cpu,
627 unsigned int *thread)
628{
629 return NULL;
630}
631
632static inline struct device_node *of_get_next_cpu_node(struct device_node *prev)
633{
634 return NULL;
635}
636
637static inline struct device_node *of_get_cpu_state_node(struct device_node *cpu_node,
638 int index)
639{
640 return NULL;
641}
642
643static inline int of_n_addr_cells(struct device_node *np)
644{
645 return 0;
646
647}
648static inline int of_n_size_cells(struct device_node *np)
649{
650 return 0;
651}
652
653static inline int of_property_read_variable_u8_array(const struct device_node *np,
654 const char *propname, u8 *out_values,
655 size_t sz_min, size_t sz_max)
656{
657 return -ENOSYS;
658}
659
660static inline int of_property_read_variable_u16_array(const struct device_node *np,
661 const char *propname, u16 *out_values,
662 size_t sz_min, size_t sz_max)
663{
664 return -ENOSYS;
665}
666
667static inline int of_property_read_variable_u32_array(const struct device_node *np,
668 const char *propname,
669 u32 *out_values,
670 size_t sz_min,
671 size_t sz_max)
672{
673 return -ENOSYS;
674}
675
676static inline int of_property_read_u64(const struct device_node *np,
677 const char *propname, u64 *out_value)
678{
679 return -ENOSYS;
680}
681
682static inline int of_property_read_variable_u64_array(const struct device_node *np,
683 const char *propname,
684 u64 *out_values,
685 size_t sz_min,
686 size_t sz_max)
687{
688 return -ENOSYS;
689}
690
691static inline int of_property_read_string(const struct device_node *np,
692 const char *propname,
693 const char **out_string)
694{
695 return -ENOSYS;
696}
697
698static inline int of_property_match_string(const struct device_node *np,
699 const char *propname,
700 const char *string)
701{
702 return -ENOSYS;
703}
704
705static inline int of_property_read_string_helper(const struct device_node *np,
706 const char *propname,
707 const char **out_strs, size_t sz, int index)
708{
709 return -ENOSYS;
710}
711
712static inline int __of_parse_phandle_with_args(const struct device_node *np,
713 const char *list_name,
714 const char *cells_name,
715 int cell_count,
716 int index,
717 struct of_phandle_args *out_args)
718{
719 return -ENOSYS;
720}
721
722static inline int of_parse_phandle_with_args_map(const struct device_node *np,
723 const char *list_name,
724 const char *stem_name,
725 int index,
726 struct of_phandle_args *out_args)
727{
728 return -ENOSYS;
729}
730
731static inline int of_count_phandle_with_args(const struct device_node *np,
732 const char *list_name,
733 const char *cells_name)
734{
735 return -ENOSYS;
736}
737
738static inline int of_phandle_iterator_init(struct of_phandle_iterator *it,
739 const struct device_node *np,
740 const char *list_name,
741 const char *cells_name,
742 int cell_count)
743{
744 return -ENOSYS;
745}
746
747static inline int of_phandle_iterator_next(struct of_phandle_iterator *it)
748{
749 return -ENOSYS;
750}
751
752static inline int of_phandle_iterator_args(struct of_phandle_iterator *it,
753 uint32_t *args,
754 int size)
755{
756 return 0;
757}
758
759static inline int of_alias_get_id(struct device_node *np, const char *stem)
760{
761 return -ENOSYS;
762}
763
764static inline int of_alias_get_highest_id(const char *stem)
765{
766 return -ENOSYS;
767}
768
769static inline int of_alias_get_alias_list(const struct of_device_id *matches,
770 const char *stem, unsigned long *bitmap,
771 unsigned int nbits)
772{
773 return -ENOSYS;
774}
775
776static inline int of_machine_is_compatible(const char *compat)
777{
778 return 0;
779}
780
781static inline int of_add_property(struct device_node *np, struct property *prop)
782{
783 return 0;
784}
785
786static inline int of_remove_property(struct device_node *np, struct property *prop)
787{
788 return 0;
789}
790
791static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
792{
793 return false;
794}
795
796static inline const __be32 *of_prop_next_u32(struct property *prop,
797 const __be32 *cur, u32 *pu)
798{
799 return NULL;
800}
801
802static inline const char *of_prop_next_string(struct property *prop,
803 const char *cur)
804{
805 return NULL;
806}
807
808static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
809{
810 return 0;
811}
812
813static inline int of_node_test_and_set_flag(struct device_node *n,
814 unsigned long flag)
815{
816 return 0;
817}
818
819static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
820{
821}
822
823static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
824{
825}
826
827static inline int of_property_check_flag(struct property *p, unsigned long flag)
828{
829 return 0;
830}
831
832static inline void of_property_set_flag(struct property *p, unsigned long flag)
833{
834}
835
836static inline void of_property_clear_flag(struct property *p, unsigned long flag)
837{
838}
839
840static inline int of_cpu_node_to_id(struct device_node *np)
841{
842 return -ENODEV;
843}
844
845static inline int of_map_id(struct device_node *np, u32 id,
846 const char *map_name, const char *map_mask_name,
847 struct device_node **target, u32 *id_out)
848{
849 return -EINVAL;
850}
851
852static inline phys_addr_t of_dma_get_max_cpu_address(struct device_node *np)
853{
854 return PHYS_ADDR_MAX;
855}
856
857#define of_match_ptr(_ptr) NULL
858#define of_match_node(_matches, _node) NULL
859#endif
860
861
862#if !defined(of_compat_cmp)
863#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
864#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
865#define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
866#endif
867
868static inline int of_prop_val_eq(struct property *p1, struct property *p2)
869{
870 return p1->length == p2->length &&
871 !memcmp(p1->value, p2->value, (size_t)p1->length);
872}
873
874#if defined(CONFIG_OF) && defined(CONFIG_NUMA)
875extern int of_node_to_nid(struct device_node *np);
876#else
877static inline int of_node_to_nid(struct device_node *device)
878{
879 return NUMA_NO_NODE;
880}
881#endif
882
883#ifdef CONFIG_OF_NUMA
884extern int of_numa_init(void);
885#else
886static inline int of_numa_init(void)
887{
888 return -ENOSYS;
889}
890#endif
891
892static inline struct device_node *of_find_matching_node(
893 struct device_node *from,
894 const struct of_device_id *matches)
895{
896 return of_find_matching_node_and_match(from, matches, NULL);
897}
898
899static inline const char *of_node_get_device_type(const struct device_node *np)
900{
901 return of_get_property(np, "device_type", NULL);
902}
903
904static inline bool of_node_is_type(const struct device_node *np, const char *type)
905{
906 const char *match = of_node_get_device_type(np);
907
908 return np && match && type && !strcmp(match, type);
909}
910
911
912
913
914
915
916
917
918
919
920
921static inline struct device_node *of_parse_phandle(const struct device_node *np,
922 const char *phandle_name,
923 int index)
924{
925 struct of_phandle_args args;
926
927 if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
928 index, &args))
929 return NULL;
930
931 return args.np;
932}
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966static inline int of_parse_phandle_with_args(const struct device_node *np,
967 const char *list_name,
968 const char *cells_name,
969 int index,
970 struct of_phandle_args *out_args)
971{
972 int cell_count = -1;
973
974
975 if (!cells_name)
976 cell_count = 0;
977
978 return __of_parse_phandle_with_args(np, list_name, cells_name,
979 cell_count, index, out_args);
980}
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
1013 const char *list_name,
1014 int cell_count,
1015 int index,
1016 struct of_phandle_args *out_args)
1017{
1018 return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
1019 index, out_args);
1020}
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035static inline int of_property_count_u8_elems(const struct device_node *np,
1036 const char *propname)
1037{
1038 return of_property_count_elems_of_size(np, propname, sizeof(u8));
1039}
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054static inline int of_property_count_u16_elems(const struct device_node *np,
1055 const char *propname)
1056{
1057 return of_property_count_elems_of_size(np, propname, sizeof(u16));
1058}
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073static inline int of_property_count_u32_elems(const struct device_node *np,
1074 const char *propname)
1075{
1076 return of_property_count_elems_of_size(np, propname, sizeof(u32));
1077}
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092static inline int of_property_count_u64_elems(const struct device_node *np,
1093 const char *propname)
1094{
1095 return of_property_count_elems_of_size(np, propname, sizeof(u64));
1096}
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111static inline int of_property_read_string_array(const struct device_node *np,
1112 const char *propname, const char **out_strs,
1113 size_t sz)
1114{
1115 return of_property_read_string_helper(np, propname, out_strs, sz, 0);
1116}
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131static inline int of_property_count_strings(const struct device_node *np,
1132 const char *propname)
1133{
1134 return of_property_read_string_helper(np, propname, NULL, 0, 0);
1135}
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156static inline int of_property_read_string_index(const struct device_node *np,
1157 const char *propname,
1158 int index, const char **output)
1159{
1160 int rc = of_property_read_string_helper(np, propname, output, 1, index);
1161 return rc < 0 ? rc : 0;
1162}
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173static inline bool of_property_read_bool(const struct device_node *np,
1174 const char *propname)
1175{
1176 struct property *prop = of_find_property(np, propname, NULL);
1177
1178 return prop ? true : false;
1179}
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201static inline int of_property_read_u8_array(const struct device_node *np,
1202 const char *propname,
1203 u8 *out_values, size_t sz)
1204{
1205 int ret = of_property_read_variable_u8_array(np, propname, out_values,
1206 sz, 0);
1207 if (ret >= 0)
1208 return 0;
1209 else
1210 return ret;
1211}
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233static inline int of_property_read_u16_array(const struct device_node *np,
1234 const char *propname,
1235 u16 *out_values, size_t sz)
1236{
1237 int ret = of_property_read_variable_u16_array(np, propname, out_values,
1238 sz, 0);
1239 if (ret >= 0)
1240 return 0;
1241 else
1242 return ret;
1243}
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263static inline int of_property_read_u32_array(const struct device_node *np,
1264 const char *propname,
1265 u32 *out_values, size_t sz)
1266{
1267 int ret = of_property_read_variable_u32_array(np, propname, out_values,
1268 sz, 0);
1269 if (ret >= 0)
1270 return 0;
1271 else
1272 return ret;
1273}
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293static inline int of_property_read_u64_array(const struct device_node *np,
1294 const char *propname,
1295 u64 *out_values, size_t sz)
1296{
1297 int ret = of_property_read_variable_u64_array(np, propname, out_values,
1298 sz, 0);
1299 if (ret >= 0)
1300 return 0;
1301 else
1302 return ret;
1303}
1304
1305static inline int of_property_read_u8(const struct device_node *np,
1306 const char *propname,
1307 u8 *out_value)
1308{
1309 return of_property_read_u8_array(np, propname, out_value, 1);
1310}
1311
1312static inline int of_property_read_u16(const struct device_node *np,
1313 const char *propname,
1314 u16 *out_value)
1315{
1316 return of_property_read_u16_array(np, propname, out_value, 1);
1317}
1318
1319static inline int of_property_read_u32(const struct device_node *np,
1320 const char *propname,
1321 u32 *out_value)
1322{
1323 return of_property_read_u32_array(np, propname, out_value, 1);
1324}
1325
1326static inline int of_property_read_s32(const struct device_node *np,
1327 const char *propname,
1328 s32 *out_value)
1329{
1330 return of_property_read_u32(np, propname, (u32*) out_value);
1331}
1332
1333#define of_for_each_phandle(it, err, np, ln, cn, cc) \
1334 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \
1335 err = of_phandle_iterator_next(it); \
1336 err == 0; \
1337 err = of_phandle_iterator_next(it))
1338
1339#define of_property_for_each_u32(np, propname, prop, p, u) \
1340 for (prop = of_find_property(np, propname, NULL), \
1341 p = of_prop_next_u32(prop, NULL, &u); \
1342 p; \
1343 p = of_prop_next_u32(prop, p, &u))
1344
1345#define of_property_for_each_string(np, propname, prop, s) \
1346 for (prop = of_find_property(np, propname, NULL), \
1347 s = of_prop_next_string(prop, NULL); \
1348 s; \
1349 s = of_prop_next_string(prop, s))
1350
1351#define for_each_node_by_name(dn, name) \
1352 for (dn = of_find_node_by_name(NULL, name); dn; \
1353 dn = of_find_node_by_name(dn, name))
1354#define for_each_node_by_type(dn, type) \
1355 for (dn = of_find_node_by_type(NULL, type); dn; \
1356 dn = of_find_node_by_type(dn, type))
1357#define for_each_compatible_node(dn, type, compatible) \
1358 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
1359 dn = of_find_compatible_node(dn, type, compatible))
1360#define for_each_matching_node(dn, matches) \
1361 for (dn = of_find_matching_node(NULL, matches); dn; \
1362 dn = of_find_matching_node(dn, matches))
1363#define for_each_matching_node_and_match(dn, matches, match) \
1364 for (dn = of_find_matching_node_and_match(NULL, matches, match); \
1365 dn; dn = of_find_matching_node_and_match(dn, matches, match))
1366
1367#define for_each_child_of_node(parent, child) \
1368 for (child = of_get_next_child(parent, NULL); child != NULL; \
1369 child = of_get_next_child(parent, child))
1370#define for_each_available_child_of_node(parent, child) \
1371 for (child = of_get_next_available_child(parent, NULL); child != NULL; \
1372 child = of_get_next_available_child(parent, child))
1373
1374#define for_each_of_cpu_node(cpu) \
1375 for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \
1376 cpu = of_get_next_cpu_node(cpu))
1377
1378#define for_each_node_with_property(dn, prop_name) \
1379 for (dn = of_find_node_with_property(NULL, prop_name); dn; \
1380 dn = of_find_node_with_property(dn, prop_name))
1381
1382static inline int of_get_child_count(const struct device_node *np)
1383{
1384 struct device_node *child;
1385 int num = 0;
1386
1387 for_each_child_of_node(np, child)
1388 num++;
1389
1390 return num;
1391}
1392
1393static inline int of_get_available_child_count(const struct device_node *np)
1394{
1395 struct device_node *child;
1396 int num = 0;
1397
1398 for_each_available_child_of_node(np, child)
1399 num++;
1400
1401 return num;
1402}
1403
1404#define _OF_DECLARE_STUB(table, name, compat, fn, fn_type) \
1405 static const struct of_device_id __of_table_##name \
1406 __attribute__((unused)) \
1407 = { .compatible = compat, \
1408 .data = (fn == (fn_type)NULL) ? fn : fn }
1409
1410#if defined(CONFIG_OF) && !defined(MODULE)
1411#define _OF_DECLARE(table, name, compat, fn, fn_type) \
1412 static const struct of_device_id __of_table_##name \
1413 __used __section("__" #table "_of_table") \
1414 __aligned(__alignof__(struct of_device_id)) \
1415 = { .compatible = compat, \
1416 .data = (fn == (fn_type)NULL) ? fn : fn }
1417#else
1418#define _OF_DECLARE(table, name, compat, fn, fn_type) \
1419 _OF_DECLARE_STUB(table, name, compat, fn, fn_type)
1420#endif
1421
1422typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
1423typedef int (*of_init_fn_1_ret)(struct device_node *);
1424typedef void (*of_init_fn_1)(struct device_node *);
1425
1426#define OF_DECLARE_1(table, name, compat, fn) \
1427 _OF_DECLARE(table, name, compat, fn, of_init_fn_1)
1428#define OF_DECLARE_1_RET(table, name, compat, fn) \
1429 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret)
1430#define OF_DECLARE_2(table, name, compat, fn) \
1431 _OF_DECLARE(table, name, compat, fn, of_init_fn_2)
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447struct of_changeset_entry {
1448 struct list_head node;
1449 unsigned long action;
1450 struct device_node *np;
1451 struct property *prop;
1452 struct property *old_prop;
1453};
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465struct of_changeset {
1466 struct list_head entries;
1467};
1468
1469enum of_reconfig_change {
1470 OF_RECONFIG_NO_CHANGE = 0,
1471 OF_RECONFIG_CHANGE_ADD,
1472 OF_RECONFIG_CHANGE_REMOVE,
1473};
1474
1475#ifdef CONFIG_OF_DYNAMIC
1476extern int of_reconfig_notifier_register(struct notifier_block *);
1477extern int of_reconfig_notifier_unregister(struct notifier_block *);
1478extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
1479extern int of_reconfig_get_state_change(unsigned long action,
1480 struct of_reconfig_data *arg);
1481
1482extern void of_changeset_init(struct of_changeset *ocs);
1483extern void of_changeset_destroy(struct of_changeset *ocs);
1484extern int of_changeset_apply(struct of_changeset *ocs);
1485extern int of_changeset_revert(struct of_changeset *ocs);
1486extern int of_changeset_action(struct of_changeset *ocs,
1487 unsigned long action, struct device_node *np,
1488 struct property *prop);
1489
1490static inline int of_changeset_attach_node(struct of_changeset *ocs,
1491 struct device_node *np)
1492{
1493 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
1494}
1495
1496static inline int of_changeset_detach_node(struct of_changeset *ocs,
1497 struct device_node *np)
1498{
1499 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
1500}
1501
1502static inline int of_changeset_add_property(struct of_changeset *ocs,
1503 struct device_node *np, struct property *prop)
1504{
1505 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
1506}
1507
1508static inline int of_changeset_remove_property(struct of_changeset *ocs,
1509 struct device_node *np, struct property *prop)
1510{
1511 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1512}
1513
1514static inline int of_changeset_update_property(struct of_changeset *ocs,
1515 struct device_node *np, struct property *prop)
1516{
1517 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
1518}
1519#else
1520static inline int of_reconfig_notifier_register(struct notifier_block *nb)
1521{
1522 return -EINVAL;
1523}
1524static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
1525{
1526 return -EINVAL;
1527}
1528static inline int of_reconfig_notify(unsigned long action,
1529 struct of_reconfig_data *arg)
1530{
1531 return -EINVAL;
1532}
1533static inline int of_reconfig_get_state_change(unsigned long action,
1534 struct of_reconfig_data *arg)
1535{
1536 return -EINVAL;
1537}
1538#endif
1539
1540
1541
1542
1543
1544
1545
1546static inline bool of_device_is_system_power_controller(const struct device_node *np)
1547{
1548 return of_property_read_bool(np, "system-power-controller");
1549}
1550
1551
1552
1553
1554
1555enum of_overlay_notify_action {
1556 OF_OVERLAY_PRE_APPLY = 0,
1557 OF_OVERLAY_POST_APPLY,
1558 OF_OVERLAY_PRE_REMOVE,
1559 OF_OVERLAY_POST_REMOVE,
1560};
1561
1562struct of_overlay_notify_data {
1563 struct device_node *overlay;
1564 struct device_node *target;
1565};
1566
1567#ifdef CONFIG_OF_OVERLAY
1568
1569int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size,
1570 int *ovcs_id);
1571int of_overlay_remove(int *ovcs_id);
1572int of_overlay_remove_all(void);
1573
1574int of_overlay_notifier_register(struct notifier_block *nb);
1575int of_overlay_notifier_unregister(struct notifier_block *nb);
1576
1577#else
1578
1579static inline int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size,
1580 int *ovcs_id)
1581{
1582 return -ENOTSUPP;
1583}
1584
1585static inline int of_overlay_remove(int *ovcs_id)
1586{
1587 return -ENOTSUPP;
1588}
1589
1590static inline int of_overlay_remove_all(void)
1591{
1592 return -ENOTSUPP;
1593}
1594
1595static inline int of_overlay_notifier_register(struct notifier_block *nb)
1596{
1597 return 0;
1598}
1599
1600static inline int of_overlay_notifier_unregister(struct notifier_block *nb)
1601{
1602 return 0;
1603}
1604
1605#endif
1606
1607#endif
1608