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