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 : : #define for_each_node_by_name(dn, name) \
173 : : for (dn = of_find_node_by_name(NULL, name); dn; \
174 : : dn = of_find_node_by_name(dn, name))
175 : : extern struct device_node *of_find_node_by_type(struct device_node *from,
176 : : const char *type);
177 : : #define for_each_node_by_type(dn, type) \
178 : : for (dn = of_find_node_by_type(NULL, type); dn; \
179 : : dn = of_find_node_by_type(dn, type))
180 : : extern struct device_node *of_find_compatible_node(struct device_node *from,
181 : : const char *type, const char *compat);
182 : : #define for_each_compatible_node(dn, type, compatible) \
183 : : for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
184 : : dn = of_find_compatible_node(dn, type, compatible))
185 : : extern struct device_node *of_find_matching_node_and_match(
186 : : struct device_node *from,
187 : : const struct of_device_id *matches,
188 : : const struct of_device_id **match);
189 : : static inline struct device_node *of_find_matching_node(
190 : : struct device_node *from,
191 : : const struct of_device_id *matches)
192 : : {
193 : 0 : return of_find_matching_node_and_match(from, matches, NULL);
194 : : }
195 : : #define for_each_matching_node(dn, matches) \
196 : : for (dn = of_find_matching_node(NULL, matches); dn; \
197 : : dn = of_find_matching_node(dn, matches))
198 : : #define for_each_matching_node_and_match(dn, matches, match) \
199 : : for (dn = of_find_matching_node_and_match(NULL, matches, match); \
200 : : dn; dn = of_find_matching_node_and_match(dn, matches, match))
201 : : extern struct device_node *of_find_node_by_path(const char *path);
202 : : extern struct device_node *of_find_node_by_phandle(phandle handle);
203 : : extern struct device_node *of_get_parent(const struct device_node *node);
204 : : extern struct device_node *of_get_next_parent(struct device_node *node);
205 : : extern struct device_node *of_get_next_child(const struct device_node *node,
206 : : struct device_node *prev);
207 : : extern struct device_node *of_get_next_available_child(
208 : : const struct device_node *node, struct device_node *prev);
209 : :
210 : : extern struct device_node *of_get_child_by_name(const struct device_node *node,
211 : : const char *name);
212 : : #define for_each_child_of_node(parent, child) \
213 : : for (child = of_get_next_child(parent, NULL); child != NULL; \
214 : : child = of_get_next_child(parent, child))
215 : :
216 : : #define for_each_available_child_of_node(parent, child) \
217 : : for (child = of_get_next_available_child(parent, NULL); child != NULL; \
218 : : child = of_get_next_available_child(parent, child))
219 : :
220 : : static inline int of_get_child_count(const struct device_node *np)
221 : : {
222 : : struct device_node *child;
223 : : int num = 0;
224 : :
225 : : for_each_child_of_node(np, child)
226 : : num++;
227 : :
228 : : return num;
229 : : }
230 : :
231 : : static inline int of_get_available_child_count(const struct device_node *np)
232 : : {
233 : : struct device_node *child;
234 : : int num = 0;
235 : :
236 [ # # ]: 0 : for_each_available_child_of_node(np, child)
237 : 0 : num++;
238 : :
239 : : return num;
240 : : }
241 : :
242 : : /* cache lookup */
243 : : extern struct device_node *of_find_next_cache_node(const struct device_node *);
244 : : extern struct device_node *of_find_node_with_property(
245 : : struct device_node *from, const char *prop_name);
246 : : #define for_each_node_with_property(dn, prop_name) \
247 : : for (dn = of_find_node_with_property(NULL, prop_name); dn; \
248 : : dn = of_find_node_with_property(dn, prop_name))
249 : :
250 : : extern struct property *of_find_property(const struct device_node *np,
251 : : const char *name,
252 : : int *lenp);
253 : : extern int of_property_read_u32_index(const struct device_node *np,
254 : : const char *propname,
255 : : u32 index, u32 *out_value);
256 : : extern int of_property_read_u8_array(const struct device_node *np,
257 : : const char *propname, u8 *out_values, size_t sz);
258 : : extern int of_property_read_u16_array(const struct device_node *np,
259 : : const char *propname, u16 *out_values, size_t sz);
260 : : extern int of_property_read_u32_array(const struct device_node *np,
261 : : const char *propname,
262 : : u32 *out_values,
263 : : size_t sz);
264 : : extern int of_property_read_u64(const struct device_node *np,
265 : : const char *propname, u64 *out_value);
266 : :
267 : : extern int of_property_read_string(struct device_node *np,
268 : : const char *propname,
269 : : const char **out_string);
270 : : extern int of_property_read_string_index(struct device_node *np,
271 : : const char *propname,
272 : : int index, const char **output);
273 : : extern int of_property_match_string(struct device_node *np,
274 : : const char *propname,
275 : : const char *string);
276 : : extern int of_property_count_strings(struct device_node *np,
277 : : const char *propname);
278 : : extern int of_device_is_compatible(const struct device_node *device,
279 : : const char *);
280 : : extern int of_device_is_available(const struct device_node *device);
281 : : extern const void *of_get_property(const struct device_node *node,
282 : : const char *name,
283 : : int *lenp);
284 : : extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
285 : : #define for_each_property_of_node(dn, pp) \
286 : : for (pp = dn->properties; pp != NULL; pp = pp->next)
287 : :
288 : : extern int of_n_addr_cells(struct device_node *np);
289 : : extern int of_n_size_cells(struct device_node *np);
290 : : extern const struct of_device_id *of_match_node(
291 : : const struct of_device_id *matches, const struct device_node *node);
292 : : extern int of_modalias_node(struct device_node *node, char *modalias, int len);
293 : : extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
294 : : extern struct device_node *of_parse_phandle(const struct device_node *np,
295 : : const char *phandle_name,
296 : : int index);
297 : : extern int of_parse_phandle_with_args(const struct device_node *np,
298 : : const char *list_name, const char *cells_name, int index,
299 : : struct of_phandle_args *out_args);
300 : : extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
301 : : const char *list_name, int cells_count, int index,
302 : : struct of_phandle_args *out_args);
303 : : extern int of_count_phandle_with_args(const struct device_node *np,
304 : : const char *list_name, const char *cells_name);
305 : :
306 : : extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
307 : : extern int of_alias_get_id(struct device_node *np, const char *stem);
308 : :
309 : : extern int of_machine_is_compatible(const char *compat);
310 : :
311 : : extern int of_add_property(struct device_node *np, struct property *prop);
312 : : extern int of_remove_property(struct device_node *np, struct property *prop);
313 : : extern int of_update_property(struct device_node *np, struct property *newprop);
314 : :
315 : : /* For updating the device tree at runtime */
316 : : #define OF_RECONFIG_ATTACH_NODE 0x0001
317 : : #define OF_RECONFIG_DETACH_NODE 0x0002
318 : : #define OF_RECONFIG_ADD_PROPERTY 0x0003
319 : : #define OF_RECONFIG_REMOVE_PROPERTY 0x0004
320 : : #define OF_RECONFIG_UPDATE_PROPERTY 0x0005
321 : :
322 : : struct of_prop_reconfig {
323 : : struct device_node *dn;
324 : : struct property *prop;
325 : : };
326 : :
327 : : extern int of_reconfig_notifier_register(struct notifier_block *);
328 : : extern int of_reconfig_notifier_unregister(struct notifier_block *);
329 : : extern int of_reconfig_notify(unsigned long, void *);
330 : :
331 : : extern int of_attach_node(struct device_node *);
332 : : extern int of_detach_node(struct device_node *);
333 : :
334 : : #define of_match_ptr(_ptr) (_ptr)
335 : :
336 : : /*
337 : : * struct property *prop;
338 : : * const __be32 *p;
339 : : * u32 u;
340 : : *
341 : : * of_property_for_each_u32(np, "propname", prop, p, u)
342 : : * printk("U32 value: %x\n", u);
343 : : */
344 : : const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
345 : : u32 *pu);
346 : : /*
347 : : * struct property *prop;
348 : : * const char *s;
349 : : *
350 : : * of_property_for_each_string(np, "propname", prop, s)
351 : : * printk("String value: %s\n", s);
352 : : */
353 : : const char *of_prop_next_string(struct property *prop, const char *cur);
354 : :
355 : : int of_device_is_stdout_path(struct device_node *dn);
356 : :
357 : : #else /* CONFIG_OF */
358 : :
359 : : static inline const char* of_node_full_name(struct device_node *np)
360 : : {
361 : : return "<no-node>";
362 : : }
363 : :
364 : : static inline struct device_node *of_find_node_by_name(struct device_node *from,
365 : : const char *name)
366 : : {
367 : : return NULL;
368 : : }
369 : :
370 : : static inline struct device_node *of_get_parent(const struct device_node *node)
371 : : {
372 : : return NULL;
373 : : }
374 : :
375 : : static inline bool of_have_populated_dt(void)
376 : : {
377 : : return false;
378 : : }
379 : :
380 : : #define for_each_child_of_node(parent, child) \
381 : : while (0)
382 : :
383 : : #define for_each_available_child_of_node(parent, child) \
384 : : while (0)
385 : :
386 : : static inline struct device_node *of_get_child_by_name(
387 : : const struct device_node *node,
388 : : const char *name)
389 : : {
390 : : return NULL;
391 : : }
392 : :
393 : : static inline int of_get_child_count(const struct device_node *np)
394 : : {
395 : : return 0;
396 : : }
397 : :
398 : : static inline int of_get_available_child_count(const struct device_node *np)
399 : : {
400 : : return 0;
401 : : }
402 : :
403 : : static inline int of_device_is_compatible(const struct device_node *device,
404 : : const char *name)
405 : : {
406 : : return 0;
407 : : }
408 : :
409 : : static inline int of_device_is_available(const struct device_node *device)
410 : : {
411 : : return 0;
412 : : }
413 : :
414 : : static inline struct property *of_find_property(const struct device_node *np,
415 : : const char *name,
416 : : int *lenp)
417 : : {
418 : : return NULL;
419 : : }
420 : :
421 : : static inline struct device_node *of_find_compatible_node(
422 : : struct device_node *from,
423 : : const char *type,
424 : : const char *compat)
425 : : {
426 : : return NULL;
427 : : }
428 : :
429 : : static inline int of_property_read_u32_index(const struct device_node *np,
430 : : const char *propname, u32 index, u32 *out_value)
431 : : {
432 : : return -ENOSYS;
433 : : }
434 : :
435 : : static inline int of_property_read_u8_array(const struct device_node *np,
436 : : const char *propname, u8 *out_values, size_t sz)
437 : : {
438 : : return -ENOSYS;
439 : : }
440 : :
441 : : static inline int of_property_read_u16_array(const struct device_node *np,
442 : : const char *propname, u16 *out_values, size_t sz)
443 : : {
444 : : return -ENOSYS;
445 : : }
446 : :
447 : : static inline int of_property_read_u32_array(const struct device_node *np,
448 : : const char *propname,
449 : : u32 *out_values, size_t sz)
450 : : {
451 : : return -ENOSYS;
452 : : }
453 : :
454 : : static inline int of_property_read_string(struct device_node *np,
455 : : const char *propname,
456 : : const char **out_string)
457 : : {
458 : : return -ENOSYS;
459 : : }
460 : :
461 : : static inline int of_property_read_string_index(struct device_node *np,
462 : : const char *propname, int index,
463 : : const char **out_string)
464 : : {
465 : : return -ENOSYS;
466 : : }
467 : :
468 : : static inline int of_property_count_strings(struct device_node *np,
469 : : const char *propname)
470 : : {
471 : : return -ENOSYS;
472 : : }
473 : :
474 : : static inline const void *of_get_property(const struct device_node *node,
475 : : const char *name,
476 : : int *lenp)
477 : : {
478 : : return NULL;
479 : : }
480 : :
481 : : static inline struct device_node *of_get_cpu_node(int cpu,
482 : : unsigned int *thread)
483 : : {
484 : : return NULL;
485 : : }
486 : :
487 : : static inline int of_property_read_u64(const struct device_node *np,
488 : : const char *propname, u64 *out_value)
489 : : {
490 : : return -ENOSYS;
491 : : }
492 : :
493 : : static inline int of_property_match_string(struct device_node *np,
494 : : const char *propname,
495 : : const char *string)
496 : : {
497 : : return -ENOSYS;
498 : : }
499 : :
500 : : static inline struct device_node *of_parse_phandle(const struct device_node *np,
501 : : const char *phandle_name,
502 : : int index)
503 : : {
504 : : return NULL;
505 : : }
506 : :
507 : : static inline int of_parse_phandle_with_args(struct device_node *np,
508 : : const char *list_name,
509 : : const char *cells_name,
510 : : int index,
511 : : struct of_phandle_args *out_args)
512 : : {
513 : : return -ENOSYS;
514 : : }
515 : :
516 : : static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
517 : : const char *list_name, int cells_count, int index,
518 : : struct of_phandle_args *out_args)
519 : : {
520 : : return -ENOSYS;
521 : : }
522 : :
523 : : static inline int of_count_phandle_with_args(struct device_node *np,
524 : : const char *list_name,
525 : : const char *cells_name)
526 : : {
527 : : return -ENOSYS;
528 : : }
529 : :
530 : : static inline int of_alias_get_id(struct device_node *np, const char *stem)
531 : : {
532 : : return -ENOSYS;
533 : : }
534 : :
535 : : static inline int of_machine_is_compatible(const char *compat)
536 : : {
537 : : return 0;
538 : : }
539 : :
540 : : static inline int of_device_is_stdout_path(struct device_node *dn)
541 : : {
542 : : return 0;
543 : : }
544 : :
545 : : static inline const __be32 *of_prop_next_u32(struct property *prop,
546 : : const __be32 *cur, u32 *pu)
547 : : {
548 : : return NULL;
549 : : }
550 : :
551 : : static inline const char *of_prop_next_string(struct property *prop,
552 : : const char *cur)
553 : : {
554 : : return NULL;
555 : : }
556 : :
557 : : #define of_match_ptr(_ptr) NULL
558 : : #define of_match_node(_matches, _node) NULL
559 : : #endif /* CONFIG_OF */
560 : :
561 : : #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
562 : : extern int of_node_to_nid(struct device_node *np);
563 : : #else
564 : : static inline int of_node_to_nid(struct device_node *device) { return 0; }
565 : : #endif
566 : :
567 : : /**
568 : : * of_property_read_bool - Findfrom a property
569 : : * @np: device node from which the property value is to be read.
570 : : * @propname: name of the property to be searched.
571 : : *
572 : : * Search for a property in a device node.
573 : : * Returns true if the property exist false otherwise.
574 : : */
575 : : static inline bool of_property_read_bool(const struct device_node *np,
576 : : const char *propname)
577 : : {
578 : 0 : struct property *prop = of_find_property(np, propname, NULL);
579 : :
580 : 0 : return prop ? true : false;
581 : : }
582 : :
583 : : static inline int of_property_read_u8(const struct device_node *np,
584 : : const char *propname,
585 : : u8 *out_value)
586 : : {
587 : : return of_property_read_u8_array(np, propname, out_value, 1);
588 : : }
589 : :
590 : : static inline int of_property_read_u16(const struct device_node *np,
591 : : const char *propname,
592 : : u16 *out_value)
593 : : {
594 : : return of_property_read_u16_array(np, propname, out_value, 1);
595 : : }
596 : :
597 : : static inline int of_property_read_u32(const struct device_node *np,
598 : : const char *propname,
599 : : u32 *out_value)
600 : : {
601 : 0 : return of_property_read_u32_array(np, propname, out_value, 1);
602 : : }
603 : :
604 : : #define of_property_for_each_u32(np, propname, prop, p, u) \
605 : : for (prop = of_find_property(np, propname, NULL), \
606 : : p = of_prop_next_u32(prop, NULL, &u); \
607 : : p; \
608 : : p = of_prop_next_u32(prop, p, &u))
609 : :
610 : : #define of_property_for_each_string(np, propname, prop, s) \
611 : : for (prop = of_find_property(np, propname, NULL), \
612 : : s = of_prop_next_string(prop, NULL); \
613 : : s; \
614 : : s = of_prop_next_string(prop, s))
615 : :
616 : : #if defined(CONFIG_PROC_FS) && defined(CONFIG_PROC_DEVICETREE)
617 : : extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
618 : : extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
619 : : extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
620 : : struct property *prop);
621 : : extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
622 : : struct property *newprop,
623 : : struct property *oldprop);
624 : : #endif
625 : :
626 : : #endif /* _LINUX_OF_H */
|
