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/kref.h>
22#include <linux/mod_devicetable.h>
23#include <linux/spinlock.h>
24#include <linux/topology.h>
25#include <linux/notifier.h>
26
27#include <asm/byteorder.h>
28#include <asm/errno.h>
29
30typedef u32 phandle;
31typedef u32 ihandle;
32
33struct property {
34 char *name;
35 int length;
36 void *value;
37 struct property *next;
38 unsigned long _flags;
39 unsigned int unique_id;
40};
41
42#if defined(CONFIG_SPARC)
43struct of_irq_controller;
44#endif
45
46struct device_node {
47 const char *name;
48 const char *type;
49 phandle phandle;
50 const char *full_name;
51
52 struct property *properties;
53 struct property *deadprops;
54 struct device_node *parent;
55 struct device_node *child;
56 struct device_node *sibling;
57 struct device_node *next;
58 struct device_node *allnext;
59 struct proc_dir_entry *pde;
60 struct kref kref;
61 unsigned long _flags;
62 void *data;
63#if defined(CONFIG_SPARC)
64 const char *path_component_name;
65 unsigned int unique_id;
66 struct of_irq_controller *irq_trans;
67#endif
68};
69
70#define MAX_PHANDLE_ARGS 8
71struct of_phandle_args {
72 struct device_node *np;
73 int args_count;
74 uint32_t args[MAX_PHANDLE_ARGS];
75};
76
77#ifdef CONFIG_OF_DYNAMIC
78extern struct device_node *of_node_get(struct device_node *node);
79extern void of_node_put(struct device_node *node);
80#else
81
82static inline struct device_node *of_node_get(struct device_node *node)
83{
84 return node;
85}
86static inline void of_node_put(struct device_node *node) { }
87#endif
88
89#ifdef CONFIG_OF
90
91
92extern struct device_node *of_allnodes;
93extern struct device_node *of_chosen;
94extern struct device_node *of_aliases;
95extern raw_spinlock_t devtree_lock;
96
97static inline bool of_have_populated_dt(void)
98{
99 return of_allnodes != NULL;
100}
101
102static inline bool of_node_is_root(const struct device_node *node)
103{
104 return node && (node->parent == NULL);
105}
106
107static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
108{
109 return test_bit(flag, &n->_flags);
110}
111
112static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
113{
114 set_bit(flag, &n->_flags);
115}
116
117extern struct device_node *of_find_all_nodes(struct device_node *prev);
118
119
120
121
122
123
124static inline u64 of_read_number(const __be32 *cell, int size)
125{
126 u64 r = 0;
127 while (size--)
128 r = (r << 32) | be32_to_cpu(*(cell++));
129 return r;
130}
131
132
133static inline unsigned long of_read_ulong(const __be32 *cell, int size)
134{
135
136 return of_read_number(cell, size);
137}
138
139#include <asm/prom.h>
140
141
142#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
143#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
144#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
145#endif
146
147
148#if !defined(of_compat_cmp)
149#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
150#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
151#define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
152#endif
153
154
155#define OF_DYNAMIC 1
156#define OF_DETACHED 2
157
158#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
159#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
160
161#define OF_BAD_ADDR ((u64)-1)
162
163static inline const char *of_node_full_name(const struct device_node *np)
164{
165 return np ? np->full_name : "<no-node>";
166}
167
168extern struct device_node *of_find_node_by_name(struct device_node *from,
169 const char *name);
170#define for_each_node_by_name(dn, name) \
171 for (dn = of_find_node_by_name(NULL, name); dn; \
172 dn = of_find_node_by_name(dn, name))
173extern struct device_node *of_find_node_by_type(struct device_node *from,
174 const char *type);
175#define for_each_node_by_type(dn, type) \
176 for (dn = of_find_node_by_type(NULL, type); dn; \
177 dn = of_find_node_by_type(dn, type))
178extern struct device_node *of_find_compatible_node(struct device_node *from,
179 const char *type, const char *compat);
180#define for_each_compatible_node(dn, type, compatible) \
181 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
182 dn = of_find_compatible_node(dn, type, compatible))
183extern struct device_node *of_find_matching_node_and_match(
184 struct device_node *from,
185 const struct of_device_id *matches,
186 const struct of_device_id **match);
187static inline struct device_node *of_find_matching_node(
188 struct device_node *from,
189 const struct of_device_id *matches)
190{
191 return of_find_matching_node_and_match(from, matches, NULL);
192}
193#define for_each_matching_node(dn, matches) \
194 for (dn = of_find_matching_node(NULL, matches); dn; \
195 dn = of_find_matching_node(dn, matches))
196#define for_each_matching_node_and_match(dn, matches, match) \
197 for (dn = of_find_matching_node_and_match(NULL, matches, match); \
198 dn; dn = of_find_matching_node_and_match(dn, matches, match))
199extern struct device_node *of_find_node_by_path(const char *path);
200extern struct device_node *of_find_node_by_phandle(phandle handle);
201extern struct device_node *of_get_parent(const struct device_node *node);
202extern struct device_node *of_get_next_parent(struct device_node *node);
203extern struct device_node *of_get_next_child(const struct device_node *node,
204 struct device_node *prev);
205extern struct device_node *of_get_next_available_child(
206 const struct device_node *node, struct device_node *prev);
207
208extern struct device_node *of_get_child_by_name(const struct device_node *node,
209 const char *name);
210#define for_each_child_of_node(parent, child) \
211 for (child = of_get_next_child(parent, NULL); child != NULL; \
212 child = of_get_next_child(parent, child))
213
214#define for_each_available_child_of_node(parent, child) \
215 for (child = of_get_next_available_child(parent, NULL); child != NULL; \
216 child = of_get_next_available_child(parent, child))
217
218static inline int of_get_child_count(const struct device_node *np)
219{
220 struct device_node *child;
221 int num = 0;
222
223 for_each_child_of_node(np, child)
224 num++;
225
226 return num;
227}
228
229extern struct device_node *of_find_node_with_property(
230 struct device_node *from, const char *prop_name);
231#define for_each_node_with_property(dn, prop_name) \
232 for (dn = of_find_node_with_property(NULL, prop_name); dn; \
233 dn = of_find_node_with_property(dn, prop_name))
234
235extern struct property *of_find_property(const struct device_node *np,
236 const char *name,
237 int *lenp);
238extern int of_property_read_u32_index(const struct device_node *np,
239 const char *propname,
240 u32 index, u32 *out_value);
241extern int of_property_read_u8_array(const struct device_node *np,
242 const char *propname, u8 *out_values, size_t sz);
243extern int of_property_read_u16_array(const struct device_node *np,
244 const char *propname, u16 *out_values, size_t sz);
245extern int of_property_read_u32_array(const struct device_node *np,
246 const char *propname,
247 u32 *out_values,
248 size_t sz);
249extern int of_property_read_u64(const struct device_node *np,
250 const char *propname, u64 *out_value);
251
252extern int of_property_read_string(struct device_node *np,
253 const char *propname,
254 const char **out_string);
255extern int of_property_read_string_index(struct device_node *np,
256 const char *propname,
257 int index, const char **output);
258extern int of_property_match_string(struct device_node *np,
259 const char *propname,
260 const char *string);
261extern int of_property_count_strings(struct device_node *np,
262 const char *propname);
263extern int of_device_is_compatible(const struct device_node *device,
264 const char *);
265extern int of_device_is_available(const struct device_node *device);
266extern const void *of_get_property(const struct device_node *node,
267 const char *name,
268 int *lenp);
269#define for_each_property_of_node(dn, pp) \
270 for (pp = dn->properties; pp != NULL; pp = pp->next)
271
272extern int of_n_addr_cells(struct device_node *np);
273extern int of_n_size_cells(struct device_node *np);
274extern const struct of_device_id *of_match_node(
275 const struct of_device_id *matches, const struct device_node *node);
276extern int of_modalias_node(struct device_node *node, char *modalias, int len);
277extern struct device_node *of_parse_phandle(const struct device_node *np,
278 const char *phandle_name,
279 int index);
280extern int of_parse_phandle_with_args(const struct device_node *np,
281 const char *list_name, const char *cells_name, int index,
282 struct of_phandle_args *out_args);
283extern int of_count_phandle_with_args(const struct device_node *np,
284 const char *list_name, const char *cells_name);
285
286extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
287extern int of_alias_get_id(struct device_node *np, const char *stem);
288
289extern int of_machine_is_compatible(const char *compat);
290
291extern int of_add_property(struct device_node *np, struct property *prop);
292extern int of_remove_property(struct device_node *np, struct property *prop);
293extern int of_update_property(struct device_node *np, struct property *newprop);
294
295
296#define OF_RECONFIG_ATTACH_NODE 0x0001
297#define OF_RECONFIG_DETACH_NODE 0x0002
298#define OF_RECONFIG_ADD_PROPERTY 0x0003
299#define OF_RECONFIG_REMOVE_PROPERTY 0x0004
300#define OF_RECONFIG_UPDATE_PROPERTY 0x0005
301
302struct of_prop_reconfig {
303 struct device_node *dn;
304 struct property *prop;
305};
306
307extern int of_reconfig_notifier_register(struct notifier_block *);
308extern int of_reconfig_notifier_unregister(struct notifier_block *);
309extern int of_reconfig_notify(unsigned long, void *);
310
311extern int of_attach_node(struct device_node *);
312extern int of_detach_node(struct device_node *);
313
314#define of_match_ptr(_ptr) (_ptr)
315
316
317
318
319
320
321
322
323
324const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
325 u32 *pu);
326#define of_property_for_each_u32(np, propname, prop, p, u) \
327 for (prop = of_find_property(np, propname, NULL), \
328 p = of_prop_next_u32(prop, NULL, &u); \
329 p; \
330 p = of_prop_next_u32(prop, p, &u))
331
332
333
334
335
336
337
338
339const char *of_prop_next_string(struct property *prop, const char *cur);
340#define of_property_for_each_string(np, propname, prop, s) \
341 for (prop = of_find_property(np, propname, NULL), \
342 s = of_prop_next_string(prop, NULL); \
343 s; \
344 s = of_prop_next_string(prop, s))
345
346#else
347
348static inline const char* of_node_full_name(struct device_node *np)
349{
350 return "<no-node>";
351}
352
353static inline struct device_node *of_find_node_by_name(struct device_node *from,
354 const char *name)
355{
356 return NULL;
357}
358
359static inline struct device_node *of_get_parent(const struct device_node *node)
360{
361 return NULL;
362}
363
364static inline bool of_have_populated_dt(void)
365{
366 return false;
367}
368
369#define for_each_child_of_node(parent, child) \
370 while (0)
371
372static inline struct device_node *of_get_child_by_name(
373 const struct device_node *node,
374 const char *name)
375{
376 return NULL;
377}
378
379static inline int of_get_child_count(const struct device_node *np)
380{
381 return 0;
382}
383
384static inline int of_device_is_compatible(const struct device_node *device,
385 const char *name)
386{
387 return 0;
388}
389
390static inline int of_device_is_available(const struct device_node *device)
391{
392 return 0;
393}
394
395static inline struct property *of_find_property(const struct device_node *np,
396 const char *name,
397 int *lenp)
398{
399 return NULL;
400}
401
402static inline struct device_node *of_find_compatible_node(
403 struct device_node *from,
404 const char *type,
405 const char *compat)
406{
407 return NULL;
408}
409
410static inline int of_property_read_u32_index(const struct device_node *np,
411 const char *propname, u32 index, u32 *out_value)
412{
413 return -ENOSYS;
414}
415
416static inline int of_property_read_u8_array(const struct device_node *np,
417 const char *propname, u8 *out_values, size_t sz)
418{
419 return -ENOSYS;
420}
421
422static inline int of_property_read_u16_array(const struct device_node *np,
423 const char *propname, u16 *out_values, size_t sz)
424{
425 return -ENOSYS;
426}
427
428static inline int of_property_read_u32_array(const struct device_node *np,
429 const char *propname,
430 u32 *out_values, size_t sz)
431{
432 return -ENOSYS;
433}
434
435static inline int of_property_read_string(struct device_node *np,
436 const char *propname,
437 const char **out_string)
438{
439 return -ENOSYS;
440}
441
442static inline int of_property_read_string_index(struct device_node *np,
443 const char *propname, int index,
444 const char **out_string)
445{
446 return -ENOSYS;
447}
448
449static inline int of_property_count_strings(struct device_node *np,
450 const char *propname)
451{
452 return -ENOSYS;
453}
454
455static inline const void *of_get_property(const struct device_node *node,
456 const char *name,
457 int *lenp)
458{
459 return NULL;
460}
461
462static inline int of_property_read_u64(const struct device_node *np,
463 const char *propname, u64 *out_value)
464{
465 return -ENOSYS;
466}
467
468static inline int of_property_match_string(struct device_node *np,
469 const char *propname,
470 const char *string)
471{
472 return -ENOSYS;
473}
474
475static inline struct device_node *of_parse_phandle(const struct device_node *np,
476 const char *phandle_name,
477 int index)
478{
479 return NULL;
480}
481
482static inline int of_parse_phandle_with_args(struct device_node *np,
483 const char *list_name,
484 const char *cells_name,
485 int index,
486 struct of_phandle_args *out_args)
487{
488 return -ENOSYS;
489}
490
491static inline int of_count_phandle_with_args(struct device_node *np,
492 const char *list_name,
493 const char *cells_name)
494{
495 return -ENOSYS;
496}
497
498static inline int of_alias_get_id(struct device_node *np, const char *stem)
499{
500 return -ENOSYS;
501}
502
503static inline int of_machine_is_compatible(const char *compat)
504{
505 return 0;
506}
507
508#define of_match_ptr(_ptr) NULL
509#define of_match_node(_matches, _node) NULL
510#define of_property_for_each_u32(np, propname, prop, p, u) \
511 while (0)
512#define of_property_for_each_string(np, propname, prop, s) \
513 while (0)
514#endif
515
516#ifndef of_node_to_nid
517static inline int of_node_to_nid(struct device_node *np)
518{
519 return numa_node_id();
520}
521
522#define of_node_to_nid of_node_to_nid
523#endif
524
525
526
527
528
529
530
531
532
533static inline bool of_property_read_bool(const struct device_node *np,
534 const char *propname)
535{
536 struct property *prop = of_find_property(np, propname, NULL);
537
538 return prop ? true : false;
539}
540
541static inline int of_property_read_u8(const struct device_node *np,
542 const char *propname,
543 u8 *out_value)
544{
545 return of_property_read_u8_array(np, propname, out_value, 1);
546}
547
548static inline int of_property_read_u16(const struct device_node *np,
549 const char *propname,
550 u16 *out_value)
551{
552 return of_property_read_u16_array(np, propname, out_value, 1);
553}
554
555static inline int of_property_read_u32(const struct device_node *np,
556 const char *propname,
557 u32 *out_value)
558{
559 return of_property_read_u32_array(np, propname, out_value, 1);
560}
561
562#if defined(CONFIG_PROC_FS) && defined(CONFIG_PROC_DEVICETREE)
563extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
564extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
565extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
566 struct property *prop);
567extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
568 struct property *newprop,
569 struct property *oldprop);
570#endif
571
572#endif
573