blob: 72843b72a2b2619a5343be071d1ad104a9cb75af [file] [log] [blame]
Stephen Rothwell76c1ce72007-05-01 16:19:07 +10001#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>
Jiri Slaby1977f032007-10-18 23:40:25 -070019#include <linux/bitops.h>
Kalle Valoe51130c2011-10-06 15:40:44 +030020#include <linux/errno.h>
Grant Likely6f192492009-10-15 10:57:49 -060021#include <linux/kref.h>
Grant Likely283029d2008-01-09 06:20:40 +110022#include <linux/mod_devicetable.h>
Grant Likely0d351c32010-02-14 14:13:57 -070023#include <linux/spinlock.h>
Paul Mundt5ca4db62012-06-03 22:04:34 -070024#include <linux/topology.h>
Stephen Rothwell76c1ce72007-05-01 16:19:07 +100025
Jeremy Kerr2e89e682010-01-30 01:41:49 -070026#include <asm/byteorder.h>
Paul Gortmakerd0a99402011-10-29 10:17:06 -040027#include <asm/errno.h>
Jeremy Kerr2e89e682010-01-30 01:41:49 -070028
Grant Likely731581e2009-10-15 10:57:46 -060029typedef u32 phandle;
30typedef u32 ihandle;
31
32struct property {
33 char *name;
34 int length;
35 void *value;
36 struct property *next;
37 unsigned long _flags;
38 unsigned int unique_id;
39};
40
Grant Likely6f192492009-10-15 10:57:49 -060041#if defined(CONFIG_SPARC)
42struct of_irq_controller;
43#endif
44
45struct device_node {
46 const char *name;
47 const char *type;
Grant Likely6016a362010-01-28 14:06:53 -070048 phandle phandle;
Grant Likely6f192492009-10-15 10:57:49 -060049 char *full_name;
50
51 struct property *properties;
52 struct property *deadprops; /* removed properties */
53 struct device_node *parent;
54 struct device_node *child;
55 struct device_node *sibling;
56 struct device_node *next; /* next device of same type */
57 struct device_node *allnext; /* next in list of all nodes */
58 struct proc_dir_entry *pde; /* this node's proc directory */
59 struct kref kref;
60 unsigned long _flags;
61 void *data;
62#if defined(CONFIG_SPARC)
63 char *path_component_name;
64 unsigned int unique_id;
65 struct of_irq_controller *irq_trans;
66#endif
67};
68
Grant Likely15c9a0a2011-12-12 09:25:57 -070069#define MAX_PHANDLE_ARGS 8
70struct of_phandle_args {
71 struct device_node *np;
72 int args_count;
73 uint32_t args[MAX_PHANDLE_ARGS];
74};
75
Grant Likely0f22dd32012-02-15 20:38:40 -070076#ifdef CONFIG_OF_DYNAMIC
77extern struct device_node *of_node_get(struct device_node *node);
78extern void of_node_put(struct device_node *node);
79#else /* CONFIG_OF_DYNAMIC */
Rob Herring3ecdd052011-12-13 09:13:54 -060080/* Dummy ref counting routines - to be implemented later */
81static inline struct device_node *of_node_get(struct device_node *node)
82{
83 return node;
84}
Grant Likely0f22dd32012-02-15 20:38:40 -070085static inline void of_node_put(struct device_node *node) { }
86#endif /* !CONFIG_OF_DYNAMIC */
Rob Herring3ecdd052011-12-13 09:13:54 -060087
Grant Likelyc9e358d2011-01-21 09:24:48 -070088#ifdef CONFIG_OF
89
Grant Likely41f88002009-11-23 20:07:01 -070090/* Pointer for first entry in chain of all nodes. */
91extern struct device_node *allnodes;
Grant Likelyfc0bdae2010-02-14 07:13:55 -070092extern struct device_node *of_chosen;
Shawn Guo611cad72011-08-15 15:28:14 +080093extern struct device_node *of_aliases;
Grant Likely0d351c32010-02-14 14:13:57 -070094extern rwlock_t devtree_lock;
Grant Likely41f88002009-11-23 20:07:01 -070095
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +010096static inline bool of_have_populated_dt(void)
97{
98 return allnodes != NULL;
99}
100
Andres Salomon035ebef2010-07-13 09:42:26 +0000101static inline bool of_node_is_root(const struct device_node *node)
102{
103 return node && (node->parent == NULL);
104}
105
Grant Likely50436312009-10-15 10:57:58 -0600106static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
107{
108 return test_bit(flag, &n->_flags);
109}
110
111static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
112{
113 set_bit(flag, &n->_flags);
114}
115
Grant Likelye91edcf2009-10-15 10:58:09 -0600116extern struct device_node *of_find_all_nodes(struct device_node *prev);
117
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600118/*
Lennert Buytenhek3d6b8822011-02-22 18:18:51 +0100119 * OF address retrieval & translation
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600120 */
121
122/* Helper to read a big number; size is in cells (not bytes) */
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700123static inline u64 of_read_number(const __be32 *cell, int size)
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600124{
125 u64 r = 0;
126 while (size--)
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700127 r = (r << 32) | be32_to_cpu(*(cell++));
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600128 return r;
129}
130
131/* Like of_read_number, but we want an unsigned long result */
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700132static inline unsigned long of_read_ulong(const __be32 *cell, int size)
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600133{
Grant Likely2be09cb2009-11-23 20:16:46 -0700134 /* toss away upper bits if unsigned long is smaller than u64 */
135 return of_read_number(cell, size);
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600136}
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600137
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000138#include <asm/prom.h>
139
Grant Likely7c7b60c2010-02-14 07:13:50 -0700140/* Default #address and #size cells. Allow arch asm/prom.h to override */
141#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
142#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
143#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
144#endif
145
146/* Default string compare functions, Allow arch asm/prom.h to override */
147#if !defined(of_compat_cmp)
Grant Likely19761522010-03-18 07:30:31 -0600148#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
Grant Likely7c7b60c2010-02-14 07:13:50 -0700149#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
150#define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
151#endif
152
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000153/* flag descriptions */
154#define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */
155#define OF_DETACHED 2 /* node has been detached from the device tree */
156
Grant Likely61e955d2009-10-15 10:57:51 -0600157#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
158#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
159
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000160#define OF_BAD_ADDR ((u64)-1)
161
Grant Likely74a7f082012-06-15 11:50:25 -0600162static inline const char* of_node_full_name(struct device_node *np)
163{
164 return np ? np->full_name : "<no-node>";
165}
166
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000167extern struct device_node *of_find_node_by_name(struct device_node *from,
168 const char *name);
169#define for_each_node_by_name(dn, name) \
170 for (dn = of_find_node_by_name(NULL, name); dn; \
171 dn = of_find_node_by_name(dn, name))
172extern struct device_node *of_find_node_by_type(struct device_node *from,
173 const char *type);
174#define for_each_node_by_type(dn, type) \
175 for (dn = of_find_node_by_type(NULL, type); dn; \
176 dn = of_find_node_by_type(dn, type))
177extern struct device_node *of_find_compatible_node(struct device_node *from,
178 const char *type, const char *compat);
179#define for_each_compatible_node(dn, type, compatible) \
180 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
181 dn = of_find_compatible_node(dn, type, compatible))
Grant Likely283029d2008-01-09 06:20:40 +1100182extern struct device_node *of_find_matching_node(struct device_node *from,
183 const struct of_device_id *matches);
184#define for_each_matching_node(dn, matches) \
185 for (dn = of_find_matching_node(NULL, matches); dn; \
186 dn = of_find_matching_node(dn, matches))
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000187extern struct device_node *of_find_node_by_path(const char *path);
188extern struct device_node *of_find_node_by_phandle(phandle handle);
189extern struct device_node *of_get_parent(const struct device_node *node);
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000190extern struct device_node *of_get_next_parent(struct device_node *node);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000191extern struct device_node *of_get_next_child(const struct device_node *node,
192 struct device_node *prev);
Timur Tabi32961932012-08-14 13:20:23 +0000193extern struct device_node *of_get_next_available_child(
194 const struct device_node *node, struct device_node *prev);
195
Srinivas Kandagatla9c197612012-09-18 08:10:28 +0100196extern struct device_node *of_get_child_by_name(const struct device_node *node,
197 const char *name);
Michael Ellermanaabc08d2007-11-26 19:03:45 +1100198#define for_each_child_of_node(parent, child) \
199 for (child = of_get_next_child(parent, NULL); child != NULL; \
200 child = of_get_next_child(parent, child))
201
Timur Tabi32961932012-08-14 13:20:23 +0000202#define for_each_available_child_of_node(parent, child) \
203 for (child = of_get_next_available_child(parent, NULL); child != NULL; \
204 child = of_get_next_available_child(parent, child))
205
Dong Aisheng183f1d02012-04-27 11:36:20 +0800206static inline int of_get_child_count(const struct device_node *np)
207{
208 struct device_node *child;
209 int num = 0;
210
211 for_each_child_of_node(np, child)
212 num++;
213
214 return num;
215}
216
Michael Ellerman1e291b12008-11-12 18:54:42 +0000217extern struct device_node *of_find_node_with_property(
218 struct device_node *from, const char *prop_name);
219#define for_each_node_with_property(dn, prop_name) \
220 for (dn = of_find_node_with_property(NULL, prop_name); dn; \
221 dn = of_find_node_with_property(dn, prop_name))
222
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000223extern struct property *of_find_property(const struct device_node *np,
224 const char *name,
225 int *lenp);
Rob Herring0e373632011-07-06 15:42:58 -0500226extern int of_property_read_u32_array(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100227 const char *propname,
Rob Herring0e373632011-07-06 15:42:58 -0500228 u32 *out_values,
229 size_t sz);
Jamie Iles4cd7f7a2011-09-14 20:49:59 +0100230extern int of_property_read_u64(const struct device_node *np,
231 const char *propname, u64 *out_value);
Rob Herring0e373632011-07-06 15:42:58 -0500232
Jamie Ilesaac285c2011-08-02 15:45:07 +0100233extern int of_property_read_string(struct device_node *np,
234 const char *propname,
235 const char **out_string);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200236extern int of_property_read_string_index(struct device_node *np,
237 const char *propname,
238 int index, const char **output);
Grant Likely7aff0fe2011-12-12 09:25:58 -0700239extern int of_property_match_string(struct device_node *np,
240 const char *propname,
241 const char *string);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200242extern int of_property_count_strings(struct device_node *np,
243 const char *propname);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000244extern int of_device_is_compatible(const struct device_node *device,
245 const char *);
Josh Boyer834d97d2008-03-27 00:33:14 +1100246extern int of_device_is_available(const struct device_node *device);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000247extern const void *of_get_property(const struct device_node *node,
248 const char *name,
249 int *lenp);
Dong Aisheng8af0da92011-12-22 20:19:24 +0800250#define for_each_property_of_node(dn, pp) \
251 for (pp = dn->properties; pp != NULL; pp = pp->next)
Shawn Guo611cad72011-08-15 15:28:14 +0800252
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000253extern int of_n_addr_cells(struct device_node *np);
254extern int of_n_size_cells(struct device_node *np);
Grant Likely283029d2008-01-09 06:20:40 +1100255extern const struct of_device_id *of_match_node(
256 const struct of_device_id *matches, const struct device_node *node);
Grant Likely3f07af42008-07-25 22:25:13 -0400257extern int of_modalias_node(struct device_node *node, char *modalias, int len);
Grant Likely739649c2009-04-25 12:52:40 +0000258extern struct device_node *of_parse_phandle(struct device_node *np,
259 const char *phandle_name,
260 int index);
Grant Likely15c9a0a2011-12-12 09:25:57 -0700261extern int of_parse_phandle_with_args(struct device_node *np,
Anton Vorontsov64b60e02008-10-10 04:43:17 +0000262 const char *list_name, const char *cells_name, int index,
Grant Likely15c9a0a2011-12-12 09:25:57 -0700263 struct of_phandle_args *out_args);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000264
Shawn Guo611cad72011-08-15 15:28:14 +0800265extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
266extern int of_alias_get_id(struct device_node *np, const char *stem);
267
Grant Likely21b082e2010-02-14 07:13:38 -0700268extern int of_machine_is_compatible(const char *compat);
269
270extern int prom_add_property(struct device_node* np, struct property* prop);
271extern int prom_remove_property(struct device_node *np, struct property *prop);
272extern int prom_update_property(struct device_node *np,
Dong Aisheng475d0092012-07-11 15:16:37 +1000273 struct property *newprop);
Grant Likely21b082e2010-02-14 07:13:38 -0700274
Grant Likelyfcdeb7f2010-01-29 05:04:33 -0700275#if defined(CONFIG_OF_DYNAMIC)
276/* For updating the device tree at runtime */
277extern void of_attach_node(struct device_node *);
278extern void of_detach_node(struct device_node *);
279#endif
280
Ben Dooks3a1e3622011-08-03 10:11:42 +0100281#define of_match_ptr(_ptr) (_ptr)
Stephen Warrenc541adc2012-04-04 09:27:46 -0600282
283/*
284 * struct property *prop;
285 * const __be32 *p;
286 * u32 u;
287 *
288 * of_property_for_each_u32(np, "propname", prop, p, u)
289 * printk("U32 value: %x\n", u);
290 */
291const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
292 u32 *pu);
293#define of_property_for_each_u32(np, propname, prop, p, u) \
294 for (prop = of_find_property(np, propname, NULL), \
295 p = of_prop_next_u32(prop, NULL, &u); \
296 p; \
297 p = of_prop_next_u32(prop, p, &u))
298
299/*
300 * struct property *prop;
301 * const char *s;
302 *
303 * of_property_for_each_string(np, "propname", prop, s)
304 * printk("String value: %s\n", s);
305 */
306const char *of_prop_next_string(struct property *prop, const char *cur);
307#define of_property_for_each_string(np, propname, prop, s) \
308 for (prop = of_find_property(np, propname, NULL), \
309 s = of_prop_next_string(prop, NULL); \
310 s; \
311 s = of_prop_next_string(prop, s))
312
Shawn Guob98c0232011-07-08 16:27:33 +0800313#else /* CONFIG_OF */
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +0100314
Grant Likely74a7f082012-06-15 11:50:25 -0600315static inline const char* of_node_full_name(struct device_node *np)
316{
317 return "<no-node>";
318}
319
Peter Ujfalusi1cc44f42012-09-10 13:46:24 +0300320static inline struct device_node *of_find_node_by_name(struct device_node *from,
321 const char *name)
322{
323 return NULL;
324}
325
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +0100326static inline bool of_have_populated_dt(void)
327{
328 return false;
329}
330
Stephen Warrenaba3dff2011-09-21 13:23:10 -0600331#define for_each_child_of_node(parent, child) \
332 while (0)
333
Dong Aisheng183f1d02012-04-27 11:36:20 +0800334static inline int of_get_child_count(const struct device_node *np)
335{
336 return 0;
337}
338
Rajendra Nayak36a09042011-10-10 21:49:35 +0530339static inline int of_device_is_compatible(const struct device_node *device,
340 const char *name)
341{
342 return 0;
343}
344
Stephen Warrenaba3dff2011-09-21 13:23:10 -0600345static inline struct property *of_find_property(const struct device_node *np,
346 const char *name,
347 int *lenp)
348{
349 return NULL;
350}
351
Shawn Guo2261cc62012-02-15 10:47:42 -0800352static inline struct device_node *of_find_compatible_node(
353 struct device_node *from,
354 const char *type,
355 const char *compat)
356{
357 return NULL;
358}
359
Shawn Guob98c0232011-07-08 16:27:33 +0800360static inline int of_property_read_u32_array(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100361 const char *propname,
362 u32 *out_values, size_t sz)
Shawn Guob98c0232011-07-08 16:27:33 +0800363{
364 return -ENOSYS;
365}
366
367static inline int of_property_read_string(struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100368 const char *propname,
369 const char **out_string)
Shawn Guob98c0232011-07-08 16:27:33 +0800370{
371 return -ENOSYS;
372}
373
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200374static inline int of_property_read_string_index(struct device_node *np,
375 const char *propname, int index,
376 const char **out_string)
377{
378 return -ENOSYS;
379}
380
381static inline int of_property_count_strings(struct device_node *np,
382 const char *propname)
383{
384 return -ENOSYS;
385}
386
Stephen Warren89272b82011-08-05 16:50:30 -0600387static inline const void *of_get_property(const struct device_node *node,
388 const char *name,
389 int *lenp)
390{
391 return NULL;
392}
393
Jamie Iles4cd7f7a2011-09-14 20:49:59 +0100394static inline int of_property_read_u64(const struct device_node *np,
395 const char *propname, u64 *out_value)
396{
397 return -ENOSYS;
398}
399
Thierry Redingbd3d5502012-04-13 16:18:34 +0200400static inline int of_property_match_string(struct device_node *np,
401 const char *propname,
402 const char *string)
403{
404 return -ENOSYS;
405}
406
Rajendra Nayak36a09042011-10-10 21:49:35 +0530407static inline struct device_node *of_parse_phandle(struct device_node *np,
408 const char *phandle_name,
409 int index)
410{
411 return NULL;
412}
413
Thierry Redinge05e5072012-04-13 16:19:21 +0200414static inline int of_parse_phandle_with_args(struct device_node *np,
415 const char *list_name,
416 const char *cells_name,
417 int index,
418 struct of_phandle_args *out_args)
419{
420 return -ENOSYS;
421}
422
Nicolas Ferreed5f8862011-10-27 11:07:28 +0200423static inline int of_alias_get_id(struct device_node *np, const char *stem)
424{
425 return -ENOSYS;
426}
427
Stephen Warren50e07f82011-10-25 14:01:26 +0200428static inline int of_machine_is_compatible(const char *compat)
429{
430 return 0;
431}
432
Ben Dooks3a1e3622011-08-03 10:11:42 +0100433#define of_match_ptr(_ptr) NULL
Nicolas Ferre5762c202011-10-24 11:53:32 +0200434#define of_match_node(_matches, _node) NULL
Stephen Warrenc541adc2012-04-04 09:27:46 -0600435#define of_property_for_each_u32(np, propname, prop, p, u) \
436 while (0)
437#define of_property_for_each_string(np, propname, prop, s) \
438 while (0)
Jeremy Kerr9dfbf202010-02-14 07:13:43 -0700439#endif /* CONFIG_OF */
Shawn Guob98c0232011-07-08 16:27:33 +0800440
Paul Mundt5ca4db62012-06-03 22:04:34 -0700441#ifndef of_node_to_nid
442static inline int of_node_to_nid(struct device_node *np)
443{
444 return numa_node_id();
445}
446
447#define of_node_to_nid of_node_to_nid
448#endif
449
Jean-Christophe PLAGNIOL-VILLARDfa4d34c2012-02-07 12:12:51 +0800450/**
451 * of_property_read_bool - Findfrom a property
452 * @np: device node from which the property value is to be read.
453 * @propname: name of the property to be searched.
454 *
455 * Search for a property in a device node.
456 * Returns true if the property exist false otherwise.
457 */
458static inline bool of_property_read_bool(const struct device_node *np,
459 const char *propname)
460{
461 struct property *prop = of_find_property(np, propname, NULL);
462
463 return prop ? true : false;
464}
465
Shawn Guob98c0232011-07-08 16:27:33 +0800466static inline int of_property_read_u32(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100467 const char *propname,
Shawn Guob98c0232011-07-08 16:27:33 +0800468 u32 *out_value)
469{
470 return of_property_read_u32_array(np, propname, out_value, 1);
471}
472
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000473#endif /* _LINUX_OF_H */