Branch data Line data Source code
1 : : #ifndef _LINUX_OF_H
2 : : #define _LINUX_OF_H
3 : : /*
4 : : * Definitions for talking to the Open Firmware PROM on
5 : : * Power Macintosh and other computers.
6 : : *
7 : : * Copyright (C) 1996-2005 Paul Mackerras.
8 : : *
9 : : * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
10 : : * Updates for SPARC64 by David S. Miller
11 : : * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp.
12 : : *
13 : : * This program is free software; you can redistribute it and/or
14 : : * modify it under the terms of the GNU General Public License
15 : : * as published by the Free Software Foundation; either version
16 : : * 2 of the License, or (at your option) any later version.
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 : :
30 : : typedef u32 phandle;
31 : : typedef u32 ihandle;
32 : :
33 : : struct 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)
43 : : struct of_irq_controller;
44 : : #endif
45 : :
46 : : struct 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; /* removed properties */
54 : : struct device_node *parent;
55 : : struct device_node *child;
56 : : struct device_node *sibling;
57 : : struct device_node *next; /* next device of same type */
58 : : struct device_node *allnext; /* next in list of all nodes */
59 : : struct proc_dir_entry *pde; /* this node's proc directory */
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
71 : : struct 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
78 : : extern struct device_node *of_node_get(struct device_node *node);
79 : : extern void of_node_put(struct device_node *node);
80 : : #else /* CONFIG_OF_DYNAMIC */
81 : : /* Dummy ref counting routines - to be implemented later */
82 : : static inline struct device_node *of_node_get(struct device_node *node)
83 : : {
84 : : return node;
85 : : }
86 : : static inline void of_node_put(struct device_node *node) { }
87 : : #endif /* !CONFIG_OF_DYNAMIC */
88 : :
89 : : #ifdef CONFIG_OF
90 : :
91 : : /* Pointer for first entry in chain of all nodes. */
92 : : extern struct device_node *of_allnodes;
93 : : extern struct device_node *of_chosen;
94 : : extern struct device_node *of_aliases;
95 : : extern raw_spinlock_t devtree_lock;
96 : :
97 : : static inline bool of_have_populated_dt(void)
98 : : {
99 : 0 : return of_allnodes != NULL;
100 : : }
101 : :
102 : : static inline bool of_node_is_root(const struct device_node *node)
103 : : {
104 : : return node && (node->parent == NULL);
105 : : }
106 : :
107 : : static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
108 : : {
109 : : return test_bit(flag, &n->_flags);
110 : : }
111 : :
112 : : static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
113 : : {
114 : : set_bit(flag, &n->_flags);
115 : : }
116 : :
117 : : extern struct device_node *of_find_all_nodes(struct device_node *prev);
118 : :
119 : : /*
120 : : * OF address retrieval & translation
121 : : */
122 : :
123 : : /* Helper to read a big number; size is in cells (not bytes) */
124 : : static inline u64 of_read_number(const __be32 *cell, int size)
125 : : {
126 : : u64 r = 0;
127 [ # # ][ # # ]: 0 : while (size--)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
128 : 0 : r = (r << 32) | be32_to_cpu(*(cell++));
129 : : return r;
130 : : }
131 : :
132 : : /* Like of_read_number, but we want an unsigned long result */
133 : : static inline unsigned long of_read_ulong(const __be32 *cell, int size)
134 : : {
135 : : /* toss away upper bits if unsigned long is smaller than u64 */
136 : 0 : return of_read_number(cell, size);
137 : : }
138 : :
139 : : #if defined(CONFIG_SPARC)
140 : : #include <asm/prom.h>
141 : : #endif
142 : :
143 : : /* Default #address and #size cells. Allow arch asm/prom.h to override */
144 : : #if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
145 : : #define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
146 : : #define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
147 : : #endif
148 : :
149 : : /* Default string compare functions, Allow arch asm/prom.h to override */
150 : : #if !defined(of_compat_cmp)
151 : : #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
152 : : #define of_prop_cmp(s1, s2) strcmp((s1), (s2))
153 : : #define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
154 : : #endif
155 : :
156 : : /* flag descriptions */
157 : : #define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */
158 : : #define OF_DETACHED 2 /* node has been detached from the device tree */
159 : :
160 : : #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
161 : : #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
162 : :
163 : : #define OF_BAD_ADDR ((u64)-1)
164 : :
165 : : static inline const char *of_node_full_name(const struct device_node *np)
166 : : {
167 [ # # ][ # # ]: 0 : return np ? np->full_name : "<no-node>";
168 : : }
169 : :
170 : : extern struct device_node *of_find_node_by_name(struct device_node *from,
171 : : const char *name);
172 : : extern struct device_node *of_find_node_by_type(struct device_node *from,
173 : : const char *type);
174 : : extern struct device_node *of_find_compatible_node(struct device_node *from,
175 : : const char *type, const char *compat);
176 : : extern struct device_node *of_find_matching_node_and_match(
177 : : struct device_node *from,
178 : : const struct of_device_id *matches,
179 : : const struct of_device_id **match);
180 : :
181 : : extern struct device_node *of_find_node_by_path(const char *path);
182 : : extern struct device_node *of_find_node_by_phandle(phandle handle);
183 : : extern struct device_node *of_get_parent(const struct device_node *node);
184 : : extern struct device_node *of_get_next_parent(struct device_node *node);
185 : : extern struct device_node *of_get_next_child(const struct device_node *node,
186 : : struct device_node *prev);
187 : : extern struct device_node *of_get_next_available_child(
188 : : const struct device_node *node, struct device_node *prev);
189 : :
190 : : extern struct device_node *of_get_child_by_name(const struct device_node *node,
191 : : const char *name);
192 : :
193 : : /* cache lookup */
194 : : extern struct device_node *of_find_next_cache_node(const struct device_node *);
195 : : extern struct device_node *of_find_node_with_property(
196 : : struct device_node *from, const char *prop_name);
197 : :
198 : : extern struct property *of_find_property(const struct device_node *np,
199 : : const char *name,
200 : : int *lenp);
201 : : extern int of_property_read_u32_index(const struct device_node *np,
202 : : const char *propname,
203 : : u32 index, u32 *out_value);
204 : : extern int of_property_read_u8_array(const struct device_node *np,
205 : : const char *propname, u8 *out_values, size_t sz);
206 : : extern int of_property_read_u16_array(const struct device_node *np,
207 : : const char *propname, u16 *out_values, size_t sz);
208 : : extern int of_property_read_u32_array(const struct device_node *np,
209 : : const char *propname,
210 : : u32 *out_values,
211 : : size_t sz);
212 : : extern int of_property_read_u64(const struct device_node *np,
213 : : const char *propname, u64 *out_value);
214 : :
215 : : extern int of_property_read_string(struct device_node *np,
216 : : const char *propname,
217 : : const char **out_string);
218 : : extern int of_property_read_string_index(struct device_node *np,
219 : : const char *propname,
220 : : int index, const char **output);
221 : : extern int of_property_match_string(struct device_node *np,
222 : : const char *propname,
223 : : const char *string);
224 : : extern int of_property_count_strings(struct device_node *np,
225 : : const char *propname);
226 : : extern int of_device_is_compatible(const struct device_node *device,
227 : : const char *);
228 : : extern int of_device_is_available(const struct device_node *device);
229 : : extern const void *of_get_property(const struct device_node *node,
230 : : const char *name,
231 : : int *lenp);
232 : : extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
233 : : #define for_each_property_of_node(dn, pp) \
234 : : for (pp = dn->properties; pp != NULL; pp = pp->next)
235 : :
236 : : extern int of_n_addr_cells(struct device_node *np);
237 : : extern int of_n_size_cells(struct device_node *np);
238 : : extern const struct of_device_id *of_match_node(
239 : : const struct of_device_id *matches, const struct device_node *node);
240 : : extern int of_modalias_node(struct device_node *node, char *modalias, int len);
241 : : extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
242 : : extern struct device_node *of_parse_phandle(const struct device_node *np,
243 : : const char *phandle_name,
244 : : int index);
245 : : extern int of_parse_phandle_with_args(const struct device_node *np,
246 : : const char *list_name, const char *cells_name, int index,
247 : : struct of_phandle_args *out_args);
248 : : extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
249 : : const char *list_name, int cells_count, int index,
250 : : struct of_phandle_args *out_args);
251 : : extern int of_count_phandle_with_args(const struct device_node *np,
252 : : const char *list_name, const char *cells_name);
253 : :
254 : : extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
255 : : extern int of_alias_get_id(struct device_node *np, const char *stem);
256 : :
257 : : extern int of_machine_is_compatible(const char *compat);
258 : :
259 : : extern int of_add_property(struct device_node *np, struct property *prop);
260 : : extern int of_remove_property(struct device_node *np, struct property *prop);
261 : : extern int of_update_property(struct device_node *np, struct property *newprop);
262 : :
263 : : /* For updating the device tree at runtime */
264 : : #define OF_RECONFIG_ATTACH_NODE 0x0001
265 : : #define OF_RECONFIG_DETACH_NODE 0x0002
266 : : #define OF_RECONFIG_ADD_PROPERTY 0x0003
267 : : #define OF_RECONFIG_REMOVE_PROPERTY 0x0004
268 : : #define OF_RECONFIG_UPDATE_PROPERTY 0x0005
269 : :
270 : : struct of_prop_reconfig {
271 : : struct device_node *dn;
272 : : struct property *prop;
273 : : };
274 : :
275 : : extern int of_reconfig_notifier_register(struct notifier_block *);
276 : : extern int of_reconfig_notifier_unregister(struct notifier_block *);
277 : : extern int of_reconfig_notify(unsigned long, void *);
278 : :
279 : : extern int of_attach_node(struct device_node *);
280 : : extern int of_detach_node(struct device_node *);
281 : :
282 : : #define of_match_ptr(_ptr) (_ptr)
283 : :
284 : : /*
285 : : * struct property *prop;
286 : : * const __be32 *p;
287 : : * u32 u;
288 : : *
289 : : * of_property_for_each_u32(np, "propname", prop, p, u)
290 : : * printk("U32 value: %x\n", u);
291 : : */
292 : : const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
293 : : u32 *pu);
294 : : /*
295 : : * struct property *prop;
296 : : * const char *s;
297 : : *
298 : : * of_property_for_each_string(np, "propname", prop, s)
299 : : * printk("String value: %s\n", s);
300 : : */
301 : : const char *of_prop_next_string(struct property *prop, const char *cur);
302 : :
303 : : int of_device_is_stdout_path(struct device_node *dn);
304 : :
305 : : #else /* CONFIG_OF */
306 : :
307 : : static inline const char* of_node_full_name(struct device_node *np)
308 : : {
309 : : return "<no-node>";
310 : : }
311 : :
312 : : static inline struct device_node *of_find_node_by_name(struct device_node *from,
313 : : const char *name)
314 : : {
315 : : return NULL;
316 : : }
317 : :
318 : : static inline struct device_node *of_find_node_by_type(struct device_node *from,
319 : : const char *type)
320 : : {
321 : : return NULL;
322 : : }
323 : :
324 : : static inline struct device_node *of_find_matching_node_and_match(
325 : : struct device_node *from,
326 : : const struct of_device_id *matches,
327 : : const struct of_device_id **match)
328 : : {
329 : : return NULL;
330 : : }
331 : :
332 : : static inline struct device_node *of_get_parent(const struct device_node *node)
333 : : {
334 : : return NULL;
335 : : }
336 : :
337 : : static inline struct device_node *of_get_next_child(
338 : : const struct device_node *node, struct device_node *prev)
339 : : {
340 : : return NULL;
341 : : }
342 : :
343 : : static inline struct device_node *of_get_next_available_child(
344 : : const struct device_node *node, struct device_node *prev)
345 : : {
346 : : return NULL;
347 : : }
348 : :
349 : : static inline struct device_node *of_find_node_with_property(
350 : : struct device_node *from, const char *prop_name)
351 : : {
352 : : return NULL;
353 : : }
354 : :
355 : : static inline bool of_have_populated_dt(void)
356 : : {
357 : : return false;
358 : : }
359 : :
360 : : static inline struct device_node *of_get_child_by_name(
361 : : const struct device_node *node,
362 : : const char *name)
363 : : {
364 : : return NULL;
365 : : }
366 : :
367 : : static inline int of_device_is_compatible(const struct device_node *device,
368 : : const char *name)
369 : : {
370 : : return 0;
371 : : }
372 : :
373 : : static inline int of_device_is_available(const struct device_node *device)
374 : : {
375 : : return 0;
376 : : }
377 : :
378 : : static inline struct property *of_find_property(const struct device_node *np,
379 : : const char *name,
380 : : int *lenp)
381 : : {
382 : : return NULL;
383 : : }
384 : :
385 : : static inline struct device_node *of_find_compatible_node(
386 : : struct device_node *from,
387 : : const char *type,
388 : : const char *compat)
389 : : {
390 : : return NULL;
391 : : }
392 : :
393 : : static inline int of_property_read_u32_index(const struct device_node *np,
394 : : const char *propname, u32 index, u32 *out_value)
395 : : {
396 : : return -ENOSYS;
397 : : }
398 : :
399 : : static inline int of_property_read_u8_array(const struct device_node *np,
400 : : const char *propname, u8 *out_values, size_t sz)
401 : : {
402 : : return -ENOSYS;
403 : : }
404 : :
405 : : static inline int of_property_read_u16_array(const struct device_node *np,
406 : : const char *propname, u16 *out_values, size_t sz)
407 : : {
408 : : return -ENOSYS;
409 : : }
410 : :
411 : : static inline int of_property_read_u32_array(const struct device_node *np,
412 : : const char *propname,
413 : : u32 *out_values, size_t sz)
414 : : {
415 : : return -ENOSYS;
416 : : }
417 : :
418 : : static inline int of_property_read_string(struct device_node *np,
419 : : const char *propname,
420 : : const char **out_string)
421 : : {
422 : : return -ENOSYS;
423 : : }
424 : :
425 : : static inline int of_property_read_string_index(struct device_node *np,
426 : : const char *propname, int index,
427 : : const char **out_string)
428 : : {
429 : : return -ENOSYS;
430 : : }
431 : :
432 : : static inline int of_property_count_strings(struct device_node *np,
433 : : const char *propname)
434 : : {
435 : : return -ENOSYS;
436 : : }
437 : :
438 : : static inline const void *of_get_property(const struct device_node *node,
439 : : const char *name,
440 : : int *lenp)
441 : : {
442 : : return NULL;
443 : : }
444 : :
445 : : static inline struct device_node *of_get_cpu_node(int cpu,
446 : : unsigned int *thread)
447 : : {
448 : : return NULL;
449 : : }
450 : :
451 : : static inline int of_property_read_u64(const struct device_node *np,
452 : : const char *propname, u64 *out_value)
453 : : {
454 : : return -ENOSYS;
455 : : }
456 : :
457 : : static inline int of_property_match_string(struct device_node *np,
458 : : const char *propname,
459 : : const char *string)
460 : : {
461 : : return -ENOSYS;
462 : : }
463 : :
464 : : static inline struct device_node *of_parse_phandle(const struct device_node *np,
465 : : const char *phandle_name,
466 : : int index)
467 : : {
468 : : return NULL;
469 : : }
470 : :
471 : : static inline int of_parse_phandle_with_args(struct device_node *np,
472 : : const char *list_name,
473 : : const char *cells_name,
474 : : int index,
475 : : struct of_phandle_args *out_args)
476 : : {
477 : : return -ENOSYS;
478 : : }
479 : :
480 : : static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
481 : : const char *list_name, int cells_count, int index,
482 : : struct of_phandle_args *out_args)
483 : : {
484 : : return -ENOSYS;
485 : : }
486 : :
487 : : static inline int of_count_phandle_with_args(struct device_node *np,
488 : : const char *list_name,
489 : : const char *cells_name)
490 : : {
491 : : return -ENOSYS;
492 : : }
493 : :
494 : : static inline int of_alias_get_id(struct device_node *np, const char *stem)
495 : : {
496 : : return -ENOSYS;
497 : : }
498 : :
499 : : static inline int of_machine_is_compatible(const char *compat)
500 : : {
501 : : return 0;
502 : : }
503 : :
504 : : static inline int of_device_is_stdout_path(struct device_node *dn)
505 : : {
506 : : return 0;
507 : : }
508 : :
509 : : static inline const __be32 *of_prop_next_u32(struct property *prop,
510 : : const __be32 *cur, u32 *pu)
511 : : {
512 : : return NULL;
513 : : }
514 : :
515 : : static inline const char *of_prop_next_string(struct property *prop,
516 : : const char *cur)
517 : : {
518 : : return NULL;
519 : : }
520 : :
521 : : #define of_match_ptr(_ptr) NULL
522 : : #define of_match_node(_matches, _node) NULL
523 : : #endif /* CONFIG_OF */
524 : :
525 : : #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
526 : : extern int of_node_to_nid(struct device_node *np);
527 : : #else
528 : : static inline int of_node_to_nid(struct device_node *device) { return 0; }
529 : : #endif
530 : :
531 : : static inline struct device_node *of_find_matching_node(
532 : : struct device_node *from,
533 : : const struct of_device_id *matches)
534 : : {
535 : 0 : return of_find_matching_node_and_match(from, matches, NULL);
536 : : }
537 : :
538 : : /**
539 : : * of_property_read_bool - Findfrom a property
540 : : * @np: device node from which the property value is to be read.
541 : : * @propname: name of the property to be searched.
542 : : *
543 : : * Search for a property in a device node.
544 : : * Returns true if the property exist false otherwise.
545 : : */
546 : : static inline bool of_property_read_bool(const struct device_node *np,
547 : : const char *propname)
548 : : {
549 : 0 : struct property *prop = of_find_property(np, propname, NULL);
550 : :
551 : 0 : return prop ? true : false;
552 : : }
553 : :
554 : : static inline int of_property_read_u8(const struct device_node *np,
555 : : const char *propname,
556 : : u8 *out_value)
557 : : {
558 : : return of_property_read_u8_array(np, propname, out_value, 1);
559 : : }
560 : :
561 : : static inline int of_property_read_u16(const struct device_node *np,
562 : : const char *propname,
563 : : u16 *out_value)
564 : : {
565 : : return of_property_read_u16_array(np, propname, out_value, 1);
566 : : }
567 : :
568 : : static inline int of_property_read_u32(const struct device_node *np,
569 : : const char *propname,
570 : : u32 *out_value)
571 : : {
572 : 0 : return of_property_read_u32_array(np, propname, out_value, 1);
573 : : }
574 : :
575 : : #define of_property_for_each_u32(np, propname, prop, p, u) \
576 : : for (prop = of_find_property(np, propname, NULL), \
577 : : p = of_prop_next_u32(prop, NULL, &u); \
578 : : p; \
579 : : p = of_prop_next_u32(prop, p, &u))
580 : :
581 : : #define of_property_for_each_string(np, propname, prop, s) \
582 : : for (prop = of_find_property(np, propname, NULL), \
583 : : s = of_prop_next_string(prop, NULL); \
584 : : s; \
585 : : s = of_prop_next_string(prop, s))
586 : :
587 : : #define for_each_node_by_name(dn, name) \
588 : : for (dn = of_find_node_by_name(NULL, name); dn; \
589 : : dn = of_find_node_by_name(dn, name))
590 : : #define for_each_node_by_type(dn, type) \
591 : : for (dn = of_find_node_by_type(NULL, type); dn; \
592 : : dn = of_find_node_by_type(dn, type))
593 : : #define for_each_compatible_node(dn, type, compatible) \
594 : : for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
595 : : dn = of_find_compatible_node(dn, type, compatible))
596 : : #define for_each_matching_node(dn, matches) \
597 : : for (dn = of_find_matching_node(NULL, matches); dn; \
598 : : dn = of_find_matching_node(dn, matches))
599 : : #define for_each_matching_node_and_match(dn, matches, match) \
600 : : for (dn = of_find_matching_node_and_match(NULL, matches, match); \
601 : : dn; dn = of_find_matching_node_and_match(dn, matches, match))
602 : :
603 : : #define for_each_child_of_node(parent, child) \
604 : : for (child = of_get_next_child(parent, NULL); child != NULL; \
605 : : child = of_get_next_child(parent, child))
606 : : #define for_each_available_child_of_node(parent, child) \
607 : : for (child = of_get_next_available_child(parent, NULL); child != NULL; \
608 : : child = of_get_next_available_child(parent, child))
609 : :
610 : : #define for_each_node_with_property(dn, prop_name) \
611 : : for (dn = of_find_node_with_property(NULL, prop_name); dn; \
612 : : dn = of_find_node_with_property(dn, prop_name))
613 : :
614 : : static inline int of_get_child_count(const struct device_node *np)
615 : : {
616 : : struct device_node *child;
617 : : int num = 0;
618 : :
619 : : for_each_child_of_node(np, child)
620 : : num++;
621 : :
622 : : return num;
623 : : }
624 : :
625 : : static inline int of_get_available_child_count(const struct device_node *np)
626 : : {
627 : : struct device_node *child;
628 : : int num = 0;
629 : :
630 [ # # ]: 0 : for_each_available_child_of_node(np, child)
631 : 0 : num++;
632 : :
633 : : return num;
634 : : }
635 : :
636 : : #if defined(CONFIG_PROC_FS) && defined(CONFIG_PROC_DEVICETREE)
637 : : extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
638 : : extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
639 : : extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
640 : : struct property *prop);
641 : : extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
642 : : struct property *newprop,
643 : : struct property *oldprop);
644 : : #endif
645 : :
646 : : #endif /* _LINUX_OF_H */
|
