projects/linux·blob v3.15 · refs

760 lines · 21.8 KiB

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/kobject.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 struct bin_attribute attr;
41};
42
43#if defined(CONFIG_SPARC)
44struct of_irq_controller;
45#endif
46
47struct device_node {
48 const char *name;
49 const char *type;
50 phandle phandle;
51 const char *full_name;
52
53 struct property *properties;
54 struct property *deadprops; /* removed properties */
55 struct device_node *parent;
56 struct device_node *child;
57 struct device_node *sibling;
58 struct device_node *next; /* next device of same type */
59 struct device_node *allnext; /* next in list of all nodes */
60 struct kobject kobj;
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 16
71struct of_phandle_args {
72 struct device_node *np;
73 int args_count;
74 uint32_t args[MAX_PHANDLE_ARGS];
75};
76
77extern int of_node_add(struct device_node *node);
78
79/* initialize a node */
80extern struct kobj_type of_node_ktype;
81static inline void of_node_init(struct device_node *node)
82{
83 kobject_init(&node->kobj, &of_node_ktype);
84}
85
86/* true when node is initialized */
87static inline int of_node_is_initialized(struct device_node *node)
88{
89 return node && node->kobj.state_initialized;
90}
91
92/* true when node is attached (i.e. present on sysfs) */
93static inline int of_node_is_attached(struct device_node *node)
94{
95 return node && node->kobj.state_in_sysfs;
96}
97
98#ifdef CONFIG_OF_DYNAMIC
99extern struct device_node *of_node_get(struct device_node *node);
100extern void of_node_put(struct device_node *node);
101#else /* CONFIG_OF_DYNAMIC */
102/* Dummy ref counting routines - to be implemented later */
103static inline struct device_node *of_node_get(struct device_node *node)
104{
105 return node;
106}
107static inline void of_node_put(struct device_node *node) { }
108#endif /* !CONFIG_OF_DYNAMIC */
109
110#ifdef CONFIG_OF
111
112/* Pointer for first entry in chain of all nodes. */
113extern struct device_node *of_allnodes;
114extern struct device_node *of_chosen;
115extern struct device_node *of_aliases;
116extern raw_spinlock_t devtree_lock;
117
118static inline bool of_have_populated_dt(void)
119{
120 return of_allnodes != NULL;
121}
122
123static inline bool of_node_is_root(const struct device_node *node)
124{
125 return node && (node->parent == NULL);
126}
127
128static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
129{
130 return test_bit(flag, &n->_flags);
131}
132
133static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
134{
135 set_bit(flag, &n->_flags);
136}
137
138static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
139{
140 clear_bit(flag, &n->_flags);
141}
142
143static inline int of_property_check_flag(struct property *p, unsigned long flag)
144{
145 return test_bit(flag, &p->_flags);
146}
147
148static inline void of_property_set_flag(struct property *p, unsigned long flag)
149{
150 set_bit(flag, &p->_flags);
151}
152
153static inline void of_property_clear_flag(struct property *p, unsigned long flag)
154{
155 clear_bit(flag, &p->_flags);
156}
157
158extern struct device_node *of_find_all_nodes(struct device_node *prev);
159
160/*
161 * OF address retrieval & translation
162 */
163
164/* Helper to read a big number; size is in cells (not bytes) */
165static inline u64 of_read_number(const __be32 *cell, int size)
166{
167 u64 r = 0;
168 while (size--)
169 r = (r << 32) | be32_to_cpu(*(cell++));
170 return r;
171}
172
173/* Like of_read_number, but we want an unsigned long result */
174static inline unsigned long of_read_ulong(const __be32 *cell, int size)
175{
176 /* toss away upper bits if unsigned long is smaller than u64 */
177 return of_read_number(cell, size);
178}
179
180#if defined(CONFIG_SPARC)
181#include <asm/prom.h>
182#endif
183
184/* Default #address and #size cells. Allow arch asm/prom.h to override */
185#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
186#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
187#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
188#endif
189
190/* Default string compare functions, Allow arch asm/prom.h to override */
191#if !defined(of_compat_cmp)
192#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
193#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
194#define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
195#endif
196
197/* flag descriptions */
198#define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */
199#define OF_DETACHED 2 /* node has been detached from the device tree */
200
201#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
202#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
203
204#define OF_BAD_ADDR ((u64)-1)
205
206static inline const char *of_node_full_name(const struct device_node *np)
207{
208 return np ? np->full_name : "<no-node>";
209}
210
211#define for_each_of_allnodes(dn) \
212 for (dn = of_allnodes; dn; dn = dn->allnext)
213extern struct device_node *of_find_node_by_name(struct device_node *from,
214 const char *name);
215extern struct device_node *of_find_node_by_type(struct device_node *from,
216 const char *type);
217extern struct device_node *of_find_compatible_node(struct device_node *from,
218 const char *type, const char *compat);
219extern struct device_node *of_find_matching_node_and_match(
220 struct device_node *from,
221 const struct of_device_id *matches,
222 const struct of_device_id **match);
223
224extern struct device_node *of_find_node_by_path(const char *path);
225extern struct device_node *of_find_node_by_phandle(phandle handle);
226extern struct device_node *of_get_parent(const struct device_node *node);
227extern struct device_node *of_get_next_parent(struct device_node *node);
228extern struct device_node *of_get_next_child(const struct device_node *node,
229 struct device_node *prev);
230extern struct device_node *of_get_next_available_child(
231 const struct device_node *node, struct device_node *prev);
232
233extern struct device_node *of_get_child_by_name(const struct device_node *node,
234 const char *name);
235
236/* cache lookup */
237extern struct device_node *of_find_next_cache_node(const struct device_node *);
238extern struct device_node *of_find_node_with_property(
239 struct device_node *from, const char *prop_name);
240
241extern struct property *of_find_property(const struct device_node *np,
242 const char *name,
243 int *lenp);
244extern int of_property_count_elems_of_size(const struct device_node *np,
245 const char *propname, int elem_size);
246extern int of_property_read_u32_index(const struct device_node *np,
247 const char *propname,
248 u32 index, u32 *out_value);
249extern int of_property_read_u8_array(const struct device_node *np,
250 const char *propname, u8 *out_values, size_t sz);
251extern int of_property_read_u16_array(const struct device_node *np,
252 const char *propname, u16 *out_values, size_t sz);
253extern int of_property_read_u32_array(const struct device_node *np,
254 const char *propname,
255 u32 *out_values,
256 size_t sz);
257extern int of_property_read_u64(const struct device_node *np,
258 const char *propname, u64 *out_value);
259
260extern int of_property_read_string(struct device_node *np,
261 const char *propname,
262 const char **out_string);
263extern int of_property_read_string_index(struct device_node *np,
264 const char *propname,
265 int index, const char **output);
266extern int of_property_match_string(struct device_node *np,
267 const char *propname,
268 const char *string);
269extern int of_property_count_strings(struct device_node *np,
270 const char *propname);
271extern int of_device_is_compatible(const struct device_node *device,
272 const char *);
273extern int of_device_is_available(const struct device_node *device);
274extern const void *of_get_property(const struct device_node *node,
275 const char *name,
276 int *lenp);
277extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
278#define for_each_property_of_node(dn, pp) \
279 for (pp = dn->properties; pp != NULL; pp = pp->next)
280
281extern int of_n_addr_cells(struct device_node *np);
282extern int of_n_size_cells(struct device_node *np);
283extern const struct of_device_id *of_match_node(
284 const struct of_device_id *matches, const struct device_node *node);
285extern int of_modalias_node(struct device_node *node, char *modalias, int len);
286extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
287extern struct device_node *of_parse_phandle(const struct device_node *np,
288 const char *phandle_name,
289 int index);
290extern int of_parse_phandle_with_args(const struct device_node *np,
291 const char *list_name, const char *cells_name, int index,
292 struct of_phandle_args *out_args);
293extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
294 const char *list_name, int cells_count, int index,
295 struct of_phandle_args *out_args);
296extern int of_count_phandle_with_args(const struct device_node *np,
297 const char *list_name, const char *cells_name);
298
299extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
300extern int of_alias_get_id(struct device_node *np, const char *stem);
301
302extern int of_machine_is_compatible(const char *compat);
303
304extern int of_add_property(struct device_node *np, struct property *prop);
305extern int of_remove_property(struct device_node *np, struct property *prop);
306extern int of_update_property(struct device_node *np, struct property *newprop);
307
308/* For updating the device tree at runtime */
309#define OF_RECONFIG_ATTACH_NODE 0x0001
310#define OF_RECONFIG_DETACH_NODE 0x0002
311#define OF_RECONFIG_ADD_PROPERTY 0x0003
312#define OF_RECONFIG_REMOVE_PROPERTY 0x0004
313#define OF_RECONFIG_UPDATE_PROPERTY 0x0005
314
315struct of_prop_reconfig {
316 struct device_node *dn;
317 struct property *prop;
318};
319
320extern int of_reconfig_notifier_register(struct notifier_block *);
321extern int of_reconfig_notifier_unregister(struct notifier_block *);
322extern int of_reconfig_notify(unsigned long, void *);
323
324extern int of_attach_node(struct device_node *);
325extern int of_detach_node(struct device_node *);
326
327#define of_match_ptr(_ptr) (_ptr)
328
329/*
330 * struct property *prop;
331 * const __be32 *p;
332 * u32 u;
333 *
334 * of_property_for_each_u32(np, "propname", prop, p, u)
335 * printk("U32 value: %x\n", u);
336 */
337const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
338 u32 *pu);
339/*
340 * struct property *prop;
341 * const char *s;
342 *
343 * of_property_for_each_string(np, "propname", prop, s)
344 * printk("String value: %s\n", s);
345 */
346const char *of_prop_next_string(struct property *prop, const char *cur);
347
348int of_device_is_stdout_path(struct device_node *dn);
349
350#else /* CONFIG_OF */
351
352static inline const char* of_node_full_name(const struct device_node *np)
353{
354 return "<no-node>";
355}
356
357static inline struct device_node *of_find_node_by_name(struct device_node *from,
358 const char *name)
359{
360 return NULL;
361}
362
363static inline struct device_node *of_find_node_by_type(struct device_node *from,
364 const char *type)
365{
366 return NULL;
367}
368
369static inline struct device_node *of_find_matching_node_and_match(
370 struct device_node *from,
371 const struct of_device_id *matches,
372 const struct of_device_id **match)
373{
374 return NULL;
375}
376
377static inline struct device_node *of_find_node_by_path(const char *path)
378{
379 return NULL;
380}
381
382static inline struct device_node *of_get_parent(const struct device_node *node)
383{
384 return NULL;
385}
386
387static inline struct device_node *of_get_next_child(
388 const struct device_node *node, struct device_node *prev)
389{
390 return NULL;
391}
392
393static inline struct device_node *of_get_next_available_child(
394 const struct device_node *node, struct device_node *prev)
395{
396 return NULL;
397}
398
399static inline struct device_node *of_find_node_with_property(
400 struct device_node *from, const char *prop_name)
401{
402 return NULL;
403}
404
405static inline bool of_have_populated_dt(void)
406{
407 return false;
408}
409
410static inline struct device_node *of_get_child_by_name(
411 const struct device_node *node,
412 const char *name)
413{
414 return NULL;
415}
416
417static inline int of_device_is_compatible(const struct device_node *device,
418 const char *name)
419{
420 return 0;
421}
422
423static inline int of_device_is_available(const struct device_node *device)
424{
425 return 0;
426}
427
428static inline struct property *of_find_property(const struct device_node *np,
429 const char *name,
430 int *lenp)
431{
432 return NULL;
433}
434
435static inline struct device_node *of_find_compatible_node(
436 struct device_node *from,
437 const char *type,
438 const char *compat)
439{
440 return NULL;
441}
442
443static inline int of_property_count_elems_of_size(const struct device_node *np,
444 const char *propname, int elem_size)
445{
446 return -ENOSYS;
447}
448
449static inline int of_property_read_u32_index(const struct device_node *np,
450 const char *propname, u32 index, u32 *out_value)
451{
452 return -ENOSYS;
453}
454
455static inline int of_property_read_u8_array(const struct device_node *np,
456 const char *propname, u8 *out_values, size_t sz)
457{
458 return -ENOSYS;
459}
460
461static inline int of_property_read_u16_array(const struct device_node *np,
462 const char *propname, u16 *out_values, size_t sz)
463{
464 return -ENOSYS;
465}
466
467static inline int of_property_read_u32_array(const struct device_node *np,
468 const char *propname,
469 u32 *out_values, size_t sz)
470{
471 return -ENOSYS;
472}
473
474static inline int of_property_read_string(struct device_node *np,
475 const char *propname,
476 const char **out_string)
477{
478 return -ENOSYS;
479}
480
481static inline int of_property_read_string_index(struct device_node *np,
482 const char *propname, int index,
483 const char **out_string)
484{
485 return -ENOSYS;
486}
487
488static inline int of_property_count_strings(struct device_node *np,
489 const char *propname)
490{
491 return -ENOSYS;
492}
493
494static inline const void *of_get_property(const struct device_node *node,
495 const char *name,
496 int *lenp)
497{
498 return NULL;
499}
500
501static inline struct device_node *of_get_cpu_node(int cpu,
502 unsigned int *thread)
503{
504 return NULL;
505}
506
507static inline int of_property_read_u64(const struct device_node *np,
508 const char *propname, u64 *out_value)
509{
510 return -ENOSYS;
511}
512
513static inline int of_property_match_string(struct device_node *np,
514 const char *propname,
515 const char *string)
516{
517 return -ENOSYS;
518}
519
520static inline struct device_node *of_parse_phandle(const struct device_node *np,
521 const char *phandle_name,
522 int index)
523{
524 return NULL;
525}
526
527static inline int of_parse_phandle_with_args(struct device_node *np,
528 const char *list_name,
529 const char *cells_name,
530 int index,
531 struct of_phandle_args *out_args)
532{
533 return -ENOSYS;
534}
535
536static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
537 const char *list_name, int cells_count, int index,
538 struct of_phandle_args *out_args)
539{
540 return -ENOSYS;
541}
542
543static inline int of_count_phandle_with_args(struct device_node *np,
544 const char *list_name,
545 const char *cells_name)
546{
547 return -ENOSYS;
548}
549
550static inline int of_alias_get_id(struct device_node *np, const char *stem)
551{
552 return -ENOSYS;
553}
554
555static inline int of_machine_is_compatible(const char *compat)
556{
557 return 0;
558}
559
560static inline int of_device_is_stdout_path(struct device_node *dn)
561{
562 return 0;
563}
564
565static inline const __be32 *of_prop_next_u32(struct property *prop,
566 const __be32 *cur, u32 *pu)
567{
568 return NULL;
569}
570
571static inline const char *of_prop_next_string(struct property *prop,
572 const char *cur)
573{
574 return NULL;
575}
576
577#define of_match_ptr(_ptr) NULL
578#define of_match_node(_matches, _node) NULL
579#endif /* CONFIG_OF */
580
581#if defined(CONFIG_OF) && defined(CONFIG_NUMA)
582extern int of_node_to_nid(struct device_node *np);
583#else
584static inline int of_node_to_nid(struct device_node *device) { return 0; }
585#endif
586
587static inline struct device_node *of_find_matching_node(
588 struct device_node *from,
589 const struct of_device_id *matches)
590{
591 return of_find_matching_node_and_match(from, matches, NULL);
592}
593
594/**
595 * of_property_count_u8_elems - Count the number of u8 elements in a property
596 *
597 * @np: device node from which the property value is to be read.
598 * @propname: name of the property to be searched.
599 *
600 * Search for a property in a device node and count the number of u8 elements
601 * in it. Returns number of elements on sucess, -EINVAL if the property does
602 * not exist or its length does not match a multiple of u8 and -ENODATA if the
603 * property does not have a value.
604 */
605static inline int of_property_count_u8_elems(const struct device_node *np,
606 const char *propname)
607{
608 return of_property_count_elems_of_size(np, propname, sizeof(u8));
609}
610
611/**
612 * of_property_count_u16_elems - Count the number of u16 elements in a property
613 *
614 * @np: device node from which the property value is to be read.
615 * @propname: name of the property to be searched.
616 *
617 * Search for a property in a device node and count the number of u16 elements
618 * in it. Returns number of elements on sucess, -EINVAL if the property does
619 * not exist or its length does not match a multiple of u16 and -ENODATA if the
620 * property does not have a value.
621 */
622static inline int of_property_count_u16_elems(const struct device_node *np,
623 const char *propname)
624{
625 return of_property_count_elems_of_size(np, propname, sizeof(u16));
626}
627
628/**
629 * of_property_count_u32_elems - Count the number of u32 elements in a property
630 *
631 * @np: device node from which the property value is to be read.
632 * @propname: name of the property to be searched.
633 *
634 * Search for a property in a device node and count the number of u32 elements
635 * in it. Returns number of elements on sucess, -EINVAL if the property does
636 * not exist or its length does not match a multiple of u32 and -ENODATA if the
637 * property does not have a value.
638 */
639static inline int of_property_count_u32_elems(const struct device_node *np,
640 const char *propname)
641{
642 return of_property_count_elems_of_size(np, propname, sizeof(u32));
643}
644
645/**
646 * of_property_count_u64_elems - Count the number of u64 elements in a property
647 *
648 * @np: device node from which the property value is to be read.
649 * @propname: name of the property to be searched.
650 *
651 * Search for a property in a device node and count the number of u64 elements
652 * in it. Returns number of elements on sucess, -EINVAL if the property does
653 * not exist or its length does not match a multiple of u64 and -ENODATA if the
654 * property does not have a value.
655 */
656static inline int of_property_count_u64_elems(const struct device_node *np,
657 const char *propname)
658{
659 return of_property_count_elems_of_size(np, propname, sizeof(u64));
660}
661
662/**
663 * of_property_read_bool - Findfrom a property
664 * @np: device node from which the property value is to be read.
665 * @propname: name of the property to be searched.
666 *
667 * Search for a property in a device node.
668 * Returns true if the property exist false otherwise.
669 */
670static inline bool of_property_read_bool(const struct device_node *np,
671 const char *propname)
672{
673 struct property *prop = of_find_property(np, propname, NULL);
674
675 return prop ? true : false;
676}
677
678static inline int of_property_read_u8(const struct device_node *np,
679 const char *propname,
680 u8 *out_value)
681{
682 return of_property_read_u8_array(np, propname, out_value, 1);
683}
684
685static inline int of_property_read_u16(const struct device_node *np,
686 const char *propname,
687 u16 *out_value)
688{
689 return of_property_read_u16_array(np, propname, out_value, 1);
690}
691
692static inline int of_property_read_u32(const struct device_node *np,
693 const char *propname,
694 u32 *out_value)
695{
696 return of_property_read_u32_array(np, propname, out_value, 1);
697}
698
699#define of_property_for_each_u32(np, propname, prop, p, u) \
700 for (prop = of_find_property(np, propname, NULL), \
701 p = of_prop_next_u32(prop, NULL, &u); \
702 p; \
703 p = of_prop_next_u32(prop, p, &u))
704
705#define of_property_for_each_string(np, propname, prop, s) \
706 for (prop = of_find_property(np, propname, NULL), \
707 s = of_prop_next_string(prop, NULL); \
708 s; \
709 s = of_prop_next_string(prop, s))
710
711#define for_each_node_by_name(dn, name) \
712 for (dn = of_find_node_by_name(NULL, name); dn; \
713 dn = of_find_node_by_name(dn, name))
714#define for_each_node_by_type(dn, type) \
715 for (dn = of_find_node_by_type(NULL, type); dn; \
716 dn = of_find_node_by_type(dn, type))
717#define for_each_compatible_node(dn, type, compatible) \
718 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
719 dn = of_find_compatible_node(dn, type, compatible))
720#define for_each_matching_node(dn, matches) \
721 for (dn = of_find_matching_node(NULL, matches); dn; \
722 dn = of_find_matching_node(dn, matches))
723#define for_each_matching_node_and_match(dn, matches, match) \
724 for (dn = of_find_matching_node_and_match(NULL, matches, match); \
725 dn; dn = of_find_matching_node_and_match(dn, matches, match))
726
727#define for_each_child_of_node(parent, child) \
728 for (child = of_get_next_child(parent, NULL); child != NULL; \
729 child = of_get_next_child(parent, child))
730#define for_each_available_child_of_node(parent, child) \
731 for (child = of_get_next_available_child(parent, NULL); child != NULL; \
732 child = of_get_next_available_child(parent, child))
733
734#define for_each_node_with_property(dn, prop_name) \
735 for (dn = of_find_node_with_property(NULL, prop_name); dn; \
736 dn = of_find_node_with_property(dn, prop_name))
737
738static inline int of_get_child_count(const struct device_node *np)
739{
740 struct device_node *child;
741 int num = 0;
742
743 for_each_child_of_node(np, child)
744 num++;
745
746 return num;
747}
748
749static inline int of_get_available_child_count(const struct device_node *np)
750{
751 struct device_node *child;
752 int num = 0;
753
754 for_each_available_child_of_node(np, child)
755 num++;
756
757 return num;
758}
759
760#endif /* _LINUX_OF_H */