1#ifndef _LINUX_OF_H
2#define _LINUX_OF_H
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/types.h>
19#include <linux/bitops.h>
20#include <linux/errno.h>
21#include <linux/kobject.h>
22#include <linux/mod_devicetable.h>
23#include <linux/spinlock.h>
24#include <linux/topology.h>
25#include <linux/notifier.h>
26#include <linux/property.h>
27#include <linux/list.h>
28
29#include <asm/byteorder.h>
30#include <asm/errno.h>
31
32typedef u32 phandle;
33typedef u32 ihandle;
34
35struct property {
36 char *name;
37 int length;
38 void *value;
39 struct property *next;
40 unsigned long _flags;
41 unsigned int unique_id;
42 struct bin_attribute attr;
43};
44
45#if defined(CONFIG_SPARC)
46struct of_irq_controller;
47#endif
48
49struct device_node {
50 const char *name;
51 const char *type;
52 phandle phandle;
53 const char *full_name;
54 struct fwnode_handle fwnode;
55
56 struct property *properties;
57 struct property *deadprops;
58 struct device_node *parent;
59 struct device_node *child;
60 struct device_node *sibling;
61 struct kobject kobj;
62 unsigned long _flags;
63 void *data;
64#if defined(CONFIG_SPARC)
65 const char *path_component_name;
66 unsigned int unique_id;
67 struct of_irq_controller *irq_trans;
68#endif
69};
70
71#define MAX_PHANDLE_ARGS 16
72struct of_phandle_args {
73 struct device_node *np;
74 int args_count;
75 uint32_t args[MAX_PHANDLE_ARGS];
76};
77
78struct of_reconfig_data {
79 struct device_node *dn;
80 struct property *prop;
81 struct property *old_prop;
82};
83
84
85extern struct kobj_type of_node_ktype;
86static inline void of_node_init(struct device_node *node)
87{
88 kobject_init(&node->kobj, &of_node_ktype);
89 node->fwnode.type = FWNODE_OF;
90}
91
92
93static inline int of_node_is_initialized(struct device_node *node)
94{
95 return node && node->kobj.state_initialized;
96}
97
98
99static inline int of_node_is_attached(struct device_node *node)
100{
101 return node && node->kobj.state_in_sysfs;
102}
103
104#ifdef CONFIG_OF_DYNAMIC
105extern struct device_node *of_node_get(struct device_node *node);
106extern void of_node_put(struct device_node *node);
107#else
108
109static inline struct device_node *of_node_get(struct device_node *node)
110{
111 return node;
112}
113static inline void of_node_put(struct device_node *node) { }
114#endif
115
116
117extern struct device_node *of_root;
118extern struct device_node *of_chosen;
119extern struct device_node *of_aliases;
120extern struct device_node *of_stdout;
121extern raw_spinlock_t devtree_lock;
122
123#ifdef CONFIG_OF
124void of_core_init(void);
125
126static inline bool is_of_node(struct fwnode_handle *fwnode)
127{
128 return fwnode && fwnode->type == FWNODE_OF;
129}
130
131static inline struct device_node *of_node(struct fwnode_handle *fwnode)
132{
133 return fwnode ? container_of(fwnode, struct device_node, fwnode) : NULL;
134}
135
136static inline bool of_have_populated_dt(void)
137{
138 return of_root != NULL;
139}
140
141static inline bool of_node_is_root(const struct device_node *node)
142{
143 return node && (node->parent == NULL);
144}
145
146static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
147{
148 return test_bit(flag, &n->_flags);
149}
150
151static inline int of_node_test_and_set_flag(struct device_node *n,
152 unsigned long flag)
153{
154 return test_and_set_bit(flag, &n->_flags);
155}
156
157static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
158{
159 set_bit(flag, &n->_flags);
160}
161
162static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
163{
164 clear_bit(flag, &n->_flags);
165}
166
167static inline int of_property_check_flag(struct property *p, unsigned long flag)
168{
169 return test_bit(flag, &p->_flags);
170}
171
172static inline void of_property_set_flag(struct property *p, unsigned long flag)
173{
174 set_bit(flag, &p->_flags);
175}
176
177static inline void of_property_clear_flag(struct property *p, unsigned long flag)
178{
179 clear_bit(flag, &p->_flags);
180}
181
182extern struct device_node *__of_find_all_nodes(struct device_node *prev);
183extern struct device_node *of_find_all_nodes(struct device_node *prev);
184
185
186
187
188
189
190static inline u64 of_read_number(const __be32 *cell, int size)
191{
192 u64 r = 0;
193 while (size--)
194 r = (r << 32) | be32_to_cpu(*(cell++));
195 return r;
196}
197
198
199static inline unsigned long of_read_ulong(const __be32 *cell, int size)
200{
201
202 return of_read_number(cell, size);
203}
204
205#if defined(CONFIG_SPARC)
206#include <asm/prom.h>
207#endif
208
209
210#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
211#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
212#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
213#endif
214
215
216#if !defined(of_compat_cmp)
217#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
218#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
219#define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
220#endif
221
222
223#define OF_DYNAMIC 1
224#define OF_DETACHED 2
225#define OF_POPULATED 3
226#define OF_POPULATED_BUS 4
227
228#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
229#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
230
231#define OF_BAD_ADDR ((u64)-1)
232
233static inline const char *of_node_full_name(const struct device_node *np)
234{
235 return np ? np->full_name : "<no-node>";
236}
237
238#define for_each_of_allnodes_from(from, dn) \
239 for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn))
240#define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn)
241extern struct device_node *of_find_node_by_name(struct device_node *from,
242 const char *name);
243extern struct device_node *of_find_node_by_type(struct device_node *from,
244 const char *type);
245extern struct device_node *of_find_compatible_node(struct device_node *from,
246 const char *type, const char *compat);
247extern struct device_node *of_find_matching_node_and_match(
248 struct device_node *from,
249 const struct of_device_id *matches,
250 const struct of_device_id **match);
251
252extern struct device_node *of_find_node_opts_by_path(const char *path,
253 const char **opts);
254static inline struct device_node *of_find_node_by_path(const char *path)
255{
256 return of_find_node_opts_by_path(path, NULL);
257}
258
259extern struct device_node *of_find_node_by_phandle(phandle handle);
260extern struct device_node *of_get_parent(const struct device_node *node);
261extern struct device_node *of_get_next_parent(struct device_node *node);
262extern struct device_node *of_get_next_child(const struct device_node *node,
263 struct device_node *prev);
264extern struct device_node *of_get_next_available_child(
265 const struct device_node *node, struct device_node *prev);
266
267extern struct device_node *of_get_child_by_name(const struct device_node *node,
268 const char *name);
269
270
271extern struct device_node *of_find_next_cache_node(const struct device_node *);
272extern struct device_node *of_find_node_with_property(
273 struct device_node *from, const char *prop_name);
274
275extern struct property *of_find_property(const struct device_node *np,
276 const char *name,
277 int *lenp);
278extern int of_property_count_elems_of_size(const struct device_node *np,
279 const char *propname, int elem_size);
280extern int of_property_read_u32_index(const struct device_node *np,
281 const char *propname,
282 u32 index, u32 *out_value);
283extern int of_property_read_u8_array(const struct device_node *np,
284 const char *propname, u8 *out_values, size_t sz);
285extern int of_property_read_u16_array(const struct device_node *np,
286 const char *propname, u16 *out_values, size_t sz);
287extern int of_property_read_u32_array(const struct device_node *np,
288 const char *propname,
289 u32 *out_values,
290 size_t sz);
291extern int of_property_read_u64(const struct device_node *np,
292 const char *propname, u64 *out_value);
293extern int of_property_read_u64_array(const struct device_node *np,
294 const char *propname,
295 u64 *out_values,
296 size_t sz);
297
298extern int of_property_read_string(struct device_node *np,
299 const char *propname,
300 const char **out_string);
301extern int of_property_match_string(struct device_node *np,
302 const char *propname,
303 const char *string);
304extern int of_property_read_string_helper(struct device_node *np,
305 const char *propname,
306 const char **out_strs, size_t sz, int index);
307extern int of_device_is_compatible(const struct device_node *device,
308 const char *);
309extern bool of_device_is_available(const struct device_node *device);
310extern bool of_device_is_big_endian(const struct device_node *device);
311extern const void *of_get_property(const struct device_node *node,
312 const char *name,
313 int *lenp);
314extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
315#define for_each_property_of_node(dn, pp) \
316 for (pp = dn->properties; pp != NULL; pp = pp->next)
317
318extern int of_n_addr_cells(struct device_node *np);
319extern int of_n_size_cells(struct device_node *np);
320extern const struct of_device_id *of_match_node(
321 const struct of_device_id *matches, const struct device_node *node);
322extern int of_modalias_node(struct device_node *node, char *modalias, int len);
323extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
324extern struct device_node *of_parse_phandle(const struct device_node *np,
325 const char *phandle_name,
326 int index);
327extern int of_parse_phandle_with_args(const struct device_node *np,
328 const char *list_name, const char *cells_name, int index,
329 struct of_phandle_args *out_args);
330extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
331 const char *list_name, int cells_count, int index,
332 struct of_phandle_args *out_args);
333extern int of_count_phandle_with_args(const struct device_node *np,
334 const char *list_name, const char *cells_name);
335
336extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
337extern int of_alias_get_id(struct device_node *np, const char *stem);
338extern int of_alias_get_highest_id(const char *stem);
339
340extern int of_machine_is_compatible(const char *compat);
341
342extern int of_add_property(struct device_node *np, struct property *prop);
343extern int of_remove_property(struct device_node *np, struct property *prop);
344extern int of_update_property(struct device_node *np, struct property *newprop);
345
346
347#define OF_RECONFIG_ATTACH_NODE 0x0001
348#define OF_RECONFIG_DETACH_NODE 0x0002
349#define OF_RECONFIG_ADD_PROPERTY 0x0003
350#define OF_RECONFIG_REMOVE_PROPERTY 0x0004
351#define OF_RECONFIG_UPDATE_PROPERTY 0x0005
352
353extern int of_attach_node(struct device_node *);
354extern int of_detach_node(struct device_node *);
355
356#define of_match_ptr(_ptr) (_ptr)
357
358
359
360
361
362
363
364
365
366const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
367 u32 *pu);
368
369
370
371
372
373
374
375const char *of_prop_next_string(struct property *prop, const char *cur);
376
377bool of_console_check(struct device_node *dn, char *name, int index);
378
379#else
380
381static inline void of_core_init(void)
382{
383}
384
385static inline bool is_of_node(struct fwnode_handle *fwnode)
386{
387 return false;
388}
389
390static inline struct device_node *of_node(struct fwnode_handle *fwnode)
391{
392 return NULL;
393}
394
395static inline const char* of_node_full_name(const struct device_node *np)
396{
397 return "<no-node>";
398}
399
400static inline struct device_node *of_find_node_by_name(struct device_node *from,
401 const char *name)
402{
403 return NULL;
404}
405
406static inline struct device_node *of_find_node_by_type(struct device_node *from,
407 const char *type)
408{
409 return NULL;
410}
411
412static inline struct device_node *of_find_matching_node_and_match(
413 struct device_node *from,
414 const struct of_device_id *matches,
415 const struct of_device_id **match)
416{
417 return NULL;
418}
419
420static inline struct device_node *of_find_node_by_path(const char *path)
421{
422 return NULL;
423}
424
425static inline struct device_node *of_find_node_opts_by_path(const char *path,
426 const char **opts)
427{
428 return NULL;
429}
430
431static inline struct device_node *of_get_parent(const struct device_node *node)
432{
433 return NULL;
434}
435
436static inline struct device_node *of_get_next_child(
437 const struct device_node *node, struct device_node *prev)
438{
439 return NULL;
440}
441
442static inline struct device_node *of_get_next_available_child(
443 const struct device_node *node, struct device_node *prev)
444{
445 return NULL;
446}
447
448static inline struct device_node *of_find_node_with_property(
449 struct device_node *from, const char *prop_name)
450{
451 return NULL;
452}
453
454static inline bool of_have_populated_dt(void)
455{
456 return false;
457}
458
459static inline struct device_node *of_get_child_by_name(
460 const struct device_node *node,
461 const char *name)
462{
463 return NULL;
464}
465
466static inline int of_device_is_compatible(const struct device_node *device,
467 const char *name)
468{
469 return 0;
470}
471
472static inline bool of_device_is_available(const struct device_node *device)
473{
474 return false;
475}
476
477static inline bool of_device_is_big_endian(const struct device_node *device)
478{
479 return false;
480}
481
482static inline struct property *of_find_property(const struct device_node *np,
483 const char *name,
484 int *lenp)
485{
486 return NULL;
487}
488
489static inline struct device_node *of_find_compatible_node(
490 struct device_node *from,
491 const char *type,
492 const char *compat)
493{
494 return NULL;
495}
496
497static inline int of_property_count_elems_of_size(const struct device_node *np,
498 const char *propname, int elem_size)
499{
500 return -ENOSYS;
501}
502
503static inline int of_property_read_u32_index(const struct device_node *np,
504 const char *propname, u32 index, u32 *out_value)
505{
506 return -ENOSYS;
507}
508
509static inline int of_property_read_u8_array(const struct device_node *np,
510 const char *propname, u8 *out_values, size_t sz)
511{
512 return -ENOSYS;
513}
514
515static inline int of_property_read_u16_array(const struct device_node *np,
516 const char *propname, u16 *out_values, size_t sz)
517{
518 return -ENOSYS;
519}
520
521static inline int of_property_read_u32_array(const struct device_node *np,
522 const char *propname,
523 u32 *out_values, size_t sz)
524{
525 return -ENOSYS;
526}
527
528static inline int of_property_read_u64_array(const struct device_node *np,
529 const char *propname,
530 u64 *out_values, size_t sz)
531{
532 return -ENOSYS;
533}
534
535static inline int of_property_read_string(struct device_node *np,
536 const char *propname,
537 const char **out_string)
538{
539 return -ENOSYS;
540}
541
542static inline int of_property_read_string_helper(struct device_node *np,
543 const char *propname,
544 const char **out_strs, size_t sz, int index)
545{
546 return -ENOSYS;
547}
548
549static inline const void *of_get_property(const struct device_node *node,
550 const char *name,
551 int *lenp)
552{
553 return NULL;
554}
555
556static inline struct device_node *of_get_cpu_node(int cpu,
557 unsigned int *thread)
558{
559 return NULL;
560}
561
562static inline int of_property_read_u64(const struct device_node *np,
563 const char *propname, u64 *out_value)
564{
565 return -ENOSYS;
566}
567
568static inline int of_property_match_string(struct device_node *np,
569 const char *propname,
570 const char *string)
571{
572 return -ENOSYS;
573}
574
575static inline struct device_node *of_parse_phandle(const struct device_node *np,
576 const char *phandle_name,
577 int index)
578{
579 return NULL;
580}
581
582static inline int of_parse_phandle_with_args(struct device_node *np,
583 const char *list_name,
584 const char *cells_name,
585 int index,
586 struct of_phandle_args *out_args)
587{
588 return -ENOSYS;
589}
590
591static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
592 const char *list_name, int cells_count, int index,
593 struct of_phandle_args *out_args)
594{
595 return -ENOSYS;
596}
597
598static inline int of_count_phandle_with_args(struct device_node *np,
599 const char *list_name,
600 const char *cells_name)
601{
602 return -ENOSYS;
603}
604
605static inline int of_alias_get_id(struct device_node *np, const char *stem)
606{
607 return -ENOSYS;
608}
609
610static inline int of_alias_get_highest_id(const char *stem)
611{
612 return -ENOSYS;
613}
614
615static inline int of_machine_is_compatible(const char *compat)
616{
617 return 0;
618}
619
620static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
621{
622 return false;
623}
624
625static inline const __be32 *of_prop_next_u32(struct property *prop,
626 const __be32 *cur, u32 *pu)
627{
628 return NULL;
629}
630
631static inline const char *of_prop_next_string(struct property *prop,
632 const char *cur)
633{
634 return NULL;
635}
636
637static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
638{
639 return 0;
640}
641
642static inline int of_node_test_and_set_flag(struct device_node *n,
643 unsigned long flag)
644{
645 return 0;
646}
647
648static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
649{
650}
651
652static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
653{
654}
655
656static inline int of_property_check_flag(struct property *p, unsigned long flag)
657{
658 return 0;
659}
660
661static inline void of_property_set_flag(struct property *p, unsigned long flag)
662{
663}
664
665static inline void of_property_clear_flag(struct property *p, unsigned long flag)
666{
667}
668
669#define of_match_ptr(_ptr) NULL
670#define of_match_node(_matches, _node) NULL
671#endif
672
673#if defined(CONFIG_OF) && defined(CONFIG_NUMA)
674extern int of_node_to_nid(struct device_node *np);
675#else
676static inline int of_node_to_nid(struct device_node *device) { return 0; }
677#endif
678
679static inline struct device_node *of_find_matching_node(
680 struct device_node *from,
681 const struct of_device_id *matches)
682{
683 return of_find_matching_node_and_match(from, matches, NULL);
684}
685
686
687
688
689
690
691
692
693
694
695
696
697static inline int of_property_count_u8_elems(const struct device_node *np,
698 const char *propname)
699{
700 return of_property_count_elems_of_size(np, propname, sizeof(u8));
701}
702
703
704
705
706
707
708
709
710
711
712
713
714static inline int of_property_count_u16_elems(const struct device_node *np,
715 const char *propname)
716{
717 return of_property_count_elems_of_size(np, propname, sizeof(u16));
718}
719
720
721
722
723
724
725
726
727
728
729
730
731static inline int of_property_count_u32_elems(const struct device_node *np,
732 const char *propname)
733{
734 return of_property_count_elems_of_size(np, propname, sizeof(u32));
735}
736
737
738
739
740
741
742
743
744
745
746
747
748static inline int of_property_count_u64_elems(const struct device_node *np,
749 const char *propname)
750{
751 return of_property_count_elems_of_size(np, propname, sizeof(u64));
752}
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767static inline int of_property_read_string_array(struct device_node *np,
768 const char *propname, const char **out_strs,
769 size_t sz)
770{
771 return of_property_read_string_helper(np, propname, out_strs, sz, 0);
772}
773
774
775
776
777
778
779
780
781
782
783
784
785
786static inline int of_property_count_strings(struct device_node *np,
787 const char *propname)
788{
789 return of_property_read_string_helper(np, propname, NULL, 0, 0);
790}
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810static inline int of_property_read_string_index(struct device_node *np,
811 const char *propname,
812 int index, const char **output)
813{
814 int rc = of_property_read_string_helper(np, propname, output, 1, index);
815 return rc < 0 ? rc : 0;
816}
817
818
819
820
821
822
823
824
825
826static inline bool of_property_read_bool(const struct device_node *np,
827 const char *propname)
828{
829 struct property *prop = of_find_property(np, propname, NULL);
830
831 return prop ? true : false;
832}
833
834static inline int of_property_read_u8(const struct device_node *np,
835 const char *propname,
836 u8 *out_value)
837{
838 return of_property_read_u8_array(np, propname, out_value, 1);
839}
840
841static inline int of_property_read_u16(const struct device_node *np,
842 const char *propname,
843 u16 *out_value)
844{
845 return of_property_read_u16_array(np, propname, out_value, 1);
846}
847
848static inline int of_property_read_u32(const struct device_node *np,
849 const char *propname,
850 u32 *out_value)
851{
852 return of_property_read_u32_array(np, propname, out_value, 1);
853}
854
855static inline int of_property_read_s32(const struct device_node *np,
856 const char *propname,
857 s32 *out_value)
858{
859 return of_property_read_u32(np, propname, (u32*) out_value);
860}
861
862#define of_property_for_each_u32(np, propname, prop, p, u) \
863 for (prop = of_find_property(np, propname, NULL), \
864 p = of_prop_next_u32(prop, NULL, &u); \
865 p; \
866 p = of_prop_next_u32(prop, p, &u))
867
868#define of_property_for_each_string(np, propname, prop, s) \
869 for (prop = of_find_property(np, propname, NULL), \
870 s = of_prop_next_string(prop, NULL); \
871 s; \
872 s = of_prop_next_string(prop, s))
873
874#define for_each_node_by_name(dn, name) \
875 for (dn = of_find_node_by_name(NULL, name); dn; \
876 dn = of_find_node_by_name(dn, name))
877#define for_each_node_by_type(dn, type) \
878 for (dn = of_find_node_by_type(NULL, type); dn; \
879 dn = of_find_node_by_type(dn, type))
880#define for_each_compatible_node(dn, type, compatible) \
881 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
882 dn = of_find_compatible_node(dn, type, compatible))
883#define for_each_matching_node(dn, matches) \
884 for (dn = of_find_matching_node(NULL, matches); dn; \
885 dn = of_find_matching_node(dn, matches))
886#define for_each_matching_node_and_match(dn, matches, match) \
887 for (dn = of_find_matching_node_and_match(NULL, matches, match); \
888 dn; dn = of_find_matching_node_and_match(dn, matches, match))
889
890#define for_each_child_of_node(parent, child) \
891 for (child = of_get_next_child(parent, NULL); child != NULL; \
892 child = of_get_next_child(parent, child))
893#define for_each_available_child_of_node(parent, child) \
894 for (child = of_get_next_available_child(parent, NULL); child != NULL; \
895 child = of_get_next_available_child(parent, child))
896
897#define for_each_node_with_property(dn, prop_name) \
898 for (dn = of_find_node_with_property(NULL, prop_name); dn; \
899 dn = of_find_node_with_property(dn, prop_name))
900
901static inline int of_get_child_count(const struct device_node *np)
902{
903 struct device_node *child;
904 int num = 0;
905
906 for_each_child_of_node(np, child)
907 num++;
908
909 return num;
910}
911
912static inline int of_get_available_child_count(const struct device_node *np)
913{
914 struct device_node *child;
915 int num = 0;
916
917 for_each_available_child_of_node(np, child)
918 num++;
919
920 return num;
921}
922
923#ifdef CONFIG_OF
924#define _OF_DECLARE(table, name, compat, fn, fn_type) \
925 static const struct of_device_id __of_table_##name \
926 __used __section(__##table##_of_table) \
927 = { .compatible = compat, \
928 .data = (fn == (fn_type)NULL) ? fn : fn }
929#else
930#define _OF_DECLARE(table, name, compat, fn, fn_type) \
931 static const struct of_device_id __of_table_##name \
932 __attribute__((unused)) \
933 = { .compatible = compat, \
934 .data = (fn == (fn_type)NULL) ? fn : fn }
935#endif
936
937typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
938typedef void (*of_init_fn_1)(struct device_node *);
939
940#define OF_DECLARE_1(table, name, compat, fn) \
941 _OF_DECLARE(table, name, compat, fn, of_init_fn_1)
942#define OF_DECLARE_2(table, name, compat, fn) \
943 _OF_DECLARE(table, name, compat, fn, of_init_fn_2)
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959struct of_changeset_entry {
960 struct list_head node;
961 unsigned long action;
962 struct device_node *np;
963 struct property *prop;
964 struct property *old_prop;
965};
966
967
968
969
970
971
972
973
974
975
976
977struct of_changeset {
978 struct list_head entries;
979};
980
981enum of_reconfig_change {
982 OF_RECONFIG_NO_CHANGE = 0,
983 OF_RECONFIG_CHANGE_ADD,
984 OF_RECONFIG_CHANGE_REMOVE,
985};
986
987#ifdef CONFIG_OF_DYNAMIC
988extern int of_reconfig_notifier_register(struct notifier_block *);
989extern int of_reconfig_notifier_unregister(struct notifier_block *);
990extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
991extern int of_reconfig_get_state_change(unsigned long action,
992 struct of_reconfig_data *arg);
993
994extern void of_changeset_init(struct of_changeset *ocs);
995extern void of_changeset_destroy(struct of_changeset *ocs);
996extern int of_changeset_apply(struct of_changeset *ocs);
997extern int of_changeset_revert(struct of_changeset *ocs);
998extern int of_changeset_action(struct of_changeset *ocs,
999 unsigned long action, struct device_node *np,
1000 struct property *prop);
1001
1002static inline int of_changeset_attach_node(struct of_changeset *ocs,
1003 struct device_node *np)
1004{
1005 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
1006}
1007
1008static inline int of_changeset_detach_node(struct of_changeset *ocs,
1009 struct device_node *np)
1010{
1011 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
1012}
1013
1014static inline int of_changeset_add_property(struct of_changeset *ocs,
1015 struct device_node *np, struct property *prop)
1016{
1017 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
1018}
1019
1020static inline int of_changeset_remove_property(struct of_changeset *ocs,
1021 struct device_node *np, struct property *prop)
1022{
1023 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1024}
1025
1026static inline int of_changeset_update_property(struct of_changeset *ocs,
1027 struct device_node *np, struct property *prop)
1028{
1029 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
1030}
1031#else
1032static inline int of_reconfig_notifier_register(struct notifier_block *nb)
1033{
1034 return -EINVAL;
1035}
1036static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
1037{
1038 return -EINVAL;
1039}
1040static inline int of_reconfig_notify(unsigned long action,
1041 struct of_reconfig_data *arg)
1042{
1043 return -EINVAL;
1044}
1045static inline int of_reconfig_get_state_change(unsigned long action,
1046 struct of_reconfig_data *arg)
1047{
1048 return -EINVAL;
1049}
1050#endif
1051
1052
1053extern int of_resolve_phandles(struct device_node *tree);
1054
1055
1056
1057
1058
1059
1060
1061static inline bool of_device_is_system_power_controller(const struct device_node *np)
1062{
1063 return of_property_read_bool(np, "system-power-controller");
1064}
1065
1066
1067
1068
1069
1070#ifdef CONFIG_OF_OVERLAY
1071
1072
1073int of_overlay_create(struct device_node *tree);
1074int of_overlay_destroy(int id);
1075int of_overlay_destroy_all(void);
1076
1077#else
1078
1079static inline int of_overlay_create(struct device_node *tree)
1080{
1081 return -ENOTSUPP;
1082}
1083
1084static inline int of_overlay_destroy(int id)
1085{
1086 return -ENOTSUPP;
1087}
1088
1089static inline int of_overlay_destroy_all(void)
1090{
1091 return -ENOTSUPP;
1092}
1093
1094#endif
1095
1096#endif
1097