blob: 374e035361353cbda6a37c9a58218fd99cf8e044 [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>
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +000025#include <linux/notifier.h>
Stephen Rothwell76c1ce72007-05-01 16:19:07 +100026
Jeremy Kerr2e89e682010-01-30 01:41:49 -070027#include <asm/byteorder.h>
Paul Gortmakerd0a99402011-10-29 10:17:06 -040028#include <asm/errno.h>
Jeremy Kerr2e89e682010-01-30 01:41:49 -070029
Grant Likely731581e2009-10-15 10:57:46 -060030typedef 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
Grant Likely6f192492009-10-15 10:57:49 -060042#if defined(CONFIG_SPARC)
43struct of_irq_controller;
44#endif
45
46struct device_node {
47 const char *name;
48 const char *type;
Grant Likely6016a362010-01-28 14:06:53 -070049 phandle phandle;
Grant Likelyc22618a2012-11-14 22:37:12 +000050 const char *full_name;
Grant Likely6f192492009-10-15 10:57:49 -060051
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)
Grant Likelyc22618a2012-11-14 22:37:12 +000064 const char *path_component_name;
Grant Likely6f192492009-10-15 10:57:49 -060065 unsigned int unique_id;
66 struct of_irq_controller *irq_trans;
67#endif
68};
69
Grant Likely15c9a0a2011-12-12 09:25:57 -070070#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
Grant Likely0f22dd32012-02-15 20:38:40 -070077#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 /* CONFIG_OF_DYNAMIC */
Rob Herring3ecdd052011-12-13 09:13:54 -060081/* Dummy ref counting routines - to be implemented later */
82static inline struct device_node *of_node_get(struct device_node *node)
83{
84 return node;
85}
Grant Likely0f22dd32012-02-15 20:38:40 -070086static inline void of_node_put(struct device_node *node) { }
87#endif /* !CONFIG_OF_DYNAMIC */
Rob Herring3ecdd052011-12-13 09:13:54 -060088
Grant Likelyc9e358d2011-01-21 09:24:48 -070089#ifdef CONFIG_OF
90
Grant Likely41f88002009-11-23 20:07:01 -070091/* Pointer for first entry in chain of all nodes. */
Randy Dunlap465aac62012-11-30 10:01:51 +000092extern struct device_node *of_allnodes;
Grant Likelyfc0bdae2010-02-14 07:13:55 -070093extern struct device_node *of_chosen;
Shawn Guo611cad72011-08-15 15:28:14 +080094extern struct device_node *of_aliases;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -050095extern raw_spinlock_t devtree_lock;
Grant Likely41f88002009-11-23 20:07:01 -070096
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +010097static inline bool of_have_populated_dt(void)
98{
Randy Dunlap465aac62012-11-30 10:01:51 +000099 return of_allnodes != NULL;
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +0100100}
101
Andres Salomon035ebef2010-07-13 09:42:26 +0000102static inline bool of_node_is_root(const struct device_node *node)
103{
104 return node && (node->parent == NULL);
105}
106
Grant Likely50436312009-10-15 10:57:58 -0600107static 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
Grant Likelye91edcf2009-10-15 10:58:09 -0600117extern struct device_node *of_find_all_nodes(struct device_node *prev);
118
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600119/*
Lennert Buytenhek3d6b8822011-02-22 18:18:51 +0100120 * OF address retrieval & translation
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600121 */
122
123/* Helper to read a big number; size is in cells (not bytes) */
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700124static inline u64 of_read_number(const __be32 *cell, int size)
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600125{
126 u64 r = 0;
127 while (size--)
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700128 r = (r << 32) | be32_to_cpu(*(cell++));
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600129 return r;
130}
131
132/* Like of_read_number, but we want an unsigned long result */
Jeremy Kerr2e89e682010-01-30 01:41:49 -0700133static inline unsigned long of_read_ulong(const __be32 *cell, int size)
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600134{
Grant Likely2be09cb2009-11-23 20:16:46 -0700135 /* toss away upper bits if unsigned long is smaller than u64 */
136 return of_read_number(cell, size);
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600137}
Grant Likelyb6caf2a2009-10-15 10:58:00 -0600138
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000139#include <asm/prom.h>
140
Grant Likely7c7b60c2010-02-14 07:13:50 -0700141/* Default #address and #size cells. Allow arch asm/prom.h to override */
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/* Default string compare functions, Allow arch asm/prom.h to override */
148#if !defined(of_compat_cmp)
Grant Likely19761522010-03-18 07:30:31 -0600149#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
Grant Likely7c7b60c2010-02-14 07:13:50 -0700150#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
151#define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
152#endif
153
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000154/* flag descriptions */
155#define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */
156#define OF_DETACHED 2 /* node has been detached from the device tree */
157
Grant Likely61e955d2009-10-15 10:57:51 -0600158#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
159#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
160
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000161#define OF_BAD_ADDR ((u64)-1)
162
Steffen Trumtrarc0a05bf2012-12-18 11:32:03 +0100163static inline const char *of_node_full_name(const struct device_node *np)
Grant Likely74a7f082012-06-15 11:50:25 -0600164{
165 return np ? np->full_name : "<no-node>";
166}
167
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000168extern 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))
Stephen Warren50c8af42012-11-20 16:12:20 -0700183extern 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}
Grant Likely283029d2008-01-09 06:20:40 +1100193#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))
Stephen Warren50c8af42012-11-20 16:12:20 -0700196#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))
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000199extern 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);
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000202extern struct device_node *of_get_next_parent(struct device_node *node);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000203extern struct device_node *of_get_next_child(const struct device_node *node,
204 struct device_node *prev);
Timur Tabi32961932012-08-14 13:20:23 +0000205extern struct device_node *of_get_next_available_child(
206 const struct device_node *node, struct device_node *prev);
207
Srinivas Kandagatla9c197612012-09-18 08:10:28 +0100208extern struct device_node *of_get_child_by_name(const struct device_node *node,
209 const char *name);
Michael Ellermanaabc08d2007-11-26 19:03:45 +1100210#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
Timur Tabi32961932012-08-14 13:20:23 +0000214#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
Dong Aisheng183f1d02012-04-27 11:36:20 +0800218static 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
Michael Ellerman1e291b12008-11-12 18:54:42 +0000229extern 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
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000235extern struct property *of_find_property(const struct device_node *np,
236 const char *name,
237 int *lenp);
Tony Prisk3daf3722013-03-23 17:02:15 +1300238extern int of_property_read_u32_index(const struct device_node *np,
239 const char *propname,
240 u32 index, u32 *out_value);
Viresh Kumarbe193242012-11-20 10:15:19 +0530241extern 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);
Rob Herring0e373632011-07-06 15:42:58 -0500245extern int of_property_read_u32_array(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100246 const char *propname,
Rob Herring0e373632011-07-06 15:42:58 -0500247 u32 *out_values,
248 size_t sz);
Jamie Iles4cd7f7a2011-09-14 20:49:59 +0100249extern int of_property_read_u64(const struct device_node *np,
250 const char *propname, u64 *out_value);
Rob Herring0e373632011-07-06 15:42:58 -0500251
Jamie Ilesaac285c2011-08-02 15:45:07 +0100252extern int of_property_read_string(struct device_node *np,
253 const char *propname,
254 const char **out_string);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200255extern int of_property_read_string_index(struct device_node *np,
256 const char *propname,
257 int index, const char **output);
Grant Likely7aff0fe2011-12-12 09:25:58 -0700258extern int of_property_match_string(struct device_node *np,
259 const char *propname,
260 const char *string);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200261extern int of_property_count_strings(struct device_node *np,
262 const char *propname);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000263extern int of_device_is_compatible(const struct device_node *device,
264 const char *);
Josh Boyer834d97d2008-03-27 00:33:14 +1100265extern int of_device_is_available(const struct device_node *device);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000266extern const void *of_get_property(const struct device_node *node,
267 const char *name,
268 int *lenp);
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100269extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
Dong Aisheng8af0da92011-12-22 20:19:24 +0800270#define for_each_property_of_node(dn, pp) \
271 for (pp = dn->properties; pp != NULL; pp = pp->next)
Shawn Guo611cad72011-08-15 15:28:14 +0800272
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000273extern int of_n_addr_cells(struct device_node *np);
274extern int of_n_size_cells(struct device_node *np);
Grant Likely283029d2008-01-09 06:20:40 +1100275extern const struct of_device_id *of_match_node(
276 const struct of_device_id *matches, const struct device_node *node);
Grant Likely3f07af42008-07-25 22:25:13 -0400277extern int of_modalias_node(struct device_node *node, char *modalias, int len);
Grant Likely624cfca2013-10-11 22:05:10 +0100278extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
Steffen Trumtrarb8fbdc42012-11-22 12:16:43 +0100279extern struct device_node *of_parse_phandle(const struct device_node *np,
Grant Likely739649c2009-04-25 12:52:40 +0000280 const char *phandle_name,
281 int index);
Guennadi Liakhovetski93c667c2012-12-10 20:41:30 +0100282extern int of_parse_phandle_with_args(const struct device_node *np,
Anton Vorontsov64b60e02008-10-10 04:43:17 +0000283 const char *list_name, const char *cells_name, int index,
Grant Likely15c9a0a2011-12-12 09:25:57 -0700284 struct of_phandle_args *out_args);
Stephen Warren035fd942013-08-14 15:27:10 -0600285extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
286 const char *list_name, int cells_count, int index,
287 struct of_phandle_args *out_args);
Grant Likelybd69f732013-02-10 22:57:21 +0000288extern int of_count_phandle_with_args(const struct device_node *np,
289 const char *list_name, const char *cells_name);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000290
Shawn Guo611cad72011-08-15 15:28:14 +0800291extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
292extern int of_alias_get_id(struct device_node *np, const char *stem);
293
Grant Likely21b082e2010-02-14 07:13:38 -0700294extern int of_machine_is_compatible(const char *compat);
295
Nathan Fontenot79d1c712012-10-02 16:58:46 +0000296extern int of_add_property(struct device_node *np, struct property *prop);
297extern int of_remove_property(struct device_node *np, struct property *prop);
298extern int of_update_property(struct device_node *np, struct property *newprop);
Grant Likely21b082e2010-02-14 07:13:38 -0700299
Grant Likelyfcdeb7f2010-01-29 05:04:33 -0700300/* For updating the device tree at runtime */
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000301#define OF_RECONFIG_ATTACH_NODE 0x0001
302#define OF_RECONFIG_DETACH_NODE 0x0002
303#define OF_RECONFIG_ADD_PROPERTY 0x0003
304#define OF_RECONFIG_REMOVE_PROPERTY 0x0004
305#define OF_RECONFIG_UPDATE_PROPERTY 0x0005
306
307struct of_prop_reconfig {
308 struct device_node *dn;
309 struct property *prop;
310};
311
312extern int of_reconfig_notifier_register(struct notifier_block *);
313extern int of_reconfig_notifier_unregister(struct notifier_block *);
314extern int of_reconfig_notify(unsigned long, void *);
315
316extern int of_attach_node(struct device_node *);
317extern int of_detach_node(struct device_node *);
Grant Likelyfcdeb7f2010-01-29 05:04:33 -0700318
Ben Dooks3a1e3622011-08-03 10:11:42 +0100319#define of_match_ptr(_ptr) (_ptr)
Stephen Warrenc541adc2012-04-04 09:27:46 -0600320
321/*
322 * struct property *prop;
323 * const __be32 *p;
324 * u32 u;
325 *
326 * of_property_for_each_u32(np, "propname", prop, p, u)
327 * printk("U32 value: %x\n", u);
328 */
329const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
330 u32 *pu);
Stephen Warrenc541adc2012-04-04 09:27:46 -0600331/*
332 * struct property *prop;
333 * const char *s;
334 *
335 * of_property_for_each_string(np, "propname", prop, s)
336 * printk("String value: %s\n", s);
337 */
338const char *of_prop_next_string(struct property *prop, const char *cur);
Stephen Warrenc541adc2012-04-04 09:27:46 -0600339
Sascha Hauer5c19e952013-08-05 14:40:44 +0200340int of_device_is_stdout_path(struct device_node *dn);
341
Shawn Guob98c0232011-07-08 16:27:33 +0800342#else /* CONFIG_OF */
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +0100343
Grant Likely74a7f082012-06-15 11:50:25 -0600344static inline const char* of_node_full_name(struct device_node *np)
345{
346 return "<no-node>";
347}
348
Peter Ujfalusi1cc44f42012-09-10 13:46:24 +0300349static inline struct device_node *of_find_node_by_name(struct device_node *from,
350 const char *name)
351{
352 return NULL;
353}
354
Alexander Shiyan066ec1d2013-04-09 19:47:40 +0400355static inline struct device_node *of_get_parent(const struct device_node *node)
356{
357 return NULL;
358}
359
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +0100360static inline bool of_have_populated_dt(void)
361{
362 return false;
363}
364
Stephen Warrenaba3dff2011-09-21 13:23:10 -0600365#define for_each_child_of_node(parent, child) \
366 while (0)
367
Olof Johansson25c040c2012-10-07 10:40:54 -0700368static inline struct device_node *of_get_child_by_name(
369 const struct device_node *node,
370 const char *name)
371{
372 return NULL;
373}
374
Dong Aisheng183f1d02012-04-27 11:36:20 +0800375static inline int of_get_child_count(const struct device_node *np)
376{
377 return 0;
378}
379
Rajendra Nayak36a09042011-10-10 21:49:35 +0530380static inline int of_device_is_compatible(const struct device_node *device,
381 const char *name)
382{
383 return 0;
384}
385
Rob Herringd7195692013-03-20 16:56:18 -0500386static inline int of_device_is_available(const struct device_node *device)
387{
388 return 0;
389}
390
Stephen Warrenaba3dff2011-09-21 13:23:10 -0600391static inline struct property *of_find_property(const struct device_node *np,
392 const char *name,
393 int *lenp)
394{
395 return NULL;
396}
397
Shawn Guo2261cc62012-02-15 10:47:42 -0800398static inline struct device_node *of_find_compatible_node(
399 struct device_node *from,
400 const char *type,
401 const char *compat)
402{
403 return NULL;
404}
405
Tony Prisk3daf3722013-03-23 17:02:15 +1300406static inline int of_property_read_u32_index(const struct device_node *np,
407 const char *propname, u32 index, u32 *out_value)
408{
409 return -ENOSYS;
410}
411
Viresh Kumarbe193242012-11-20 10:15:19 +0530412static inline int of_property_read_u8_array(const struct device_node *np,
413 const char *propname, u8 *out_values, size_t sz)
414{
415 return -ENOSYS;
416}
417
418static inline int of_property_read_u16_array(const struct device_node *np,
419 const char *propname, u16 *out_values, size_t sz)
420{
421 return -ENOSYS;
422}
423
Shawn Guob98c0232011-07-08 16:27:33 +0800424static inline int of_property_read_u32_array(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100425 const char *propname,
426 u32 *out_values, size_t sz)
Shawn Guob98c0232011-07-08 16:27:33 +0800427{
428 return -ENOSYS;
429}
430
431static inline int of_property_read_string(struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100432 const char *propname,
433 const char **out_string)
Shawn Guob98c0232011-07-08 16:27:33 +0800434{
435 return -ENOSYS;
436}
437
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200438static inline int of_property_read_string_index(struct device_node *np,
439 const char *propname, int index,
440 const char **out_string)
441{
442 return -ENOSYS;
443}
444
445static inline int of_property_count_strings(struct device_node *np,
446 const char *propname)
447{
448 return -ENOSYS;
449}
450
Stephen Warren89272b82011-08-05 16:50:30 -0600451static inline const void *of_get_property(const struct device_node *node,
452 const char *name,
453 int *lenp)
454{
455 return NULL;
456}
457
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100458static inline struct device_node *of_get_cpu_node(int cpu,
459 unsigned int *thread)
460{
461 return NULL;
462}
463
Jamie Iles4cd7f7a2011-09-14 20:49:59 +0100464static inline int of_property_read_u64(const struct device_node *np,
465 const char *propname, u64 *out_value)
466{
467 return -ENOSYS;
468}
469
Thierry Redingbd3d5502012-04-13 16:18:34 +0200470static inline int of_property_match_string(struct device_node *np,
471 const char *propname,
472 const char *string)
473{
474 return -ENOSYS;
475}
476
Steffen Trumtrarb8fbdc42012-11-22 12:16:43 +0100477static inline struct device_node *of_parse_phandle(const struct device_node *np,
Rajendra Nayak36a09042011-10-10 21:49:35 +0530478 const char *phandle_name,
479 int index)
480{
481 return NULL;
482}
483
Thierry Redinge05e5072012-04-13 16:19:21 +0200484static inline int of_parse_phandle_with_args(struct device_node *np,
485 const char *list_name,
486 const char *cells_name,
487 int index,
488 struct of_phandle_args *out_args)
489{
490 return -ENOSYS;
491}
492
Stephen Warren035fd942013-08-14 15:27:10 -0600493static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
494 const char *list_name, int cells_count, int index,
495 struct of_phandle_args *out_args)
496{
497 return -ENOSYS;
498}
499
Grant Likelybd69f732013-02-10 22:57:21 +0000500static inline int of_count_phandle_with_args(struct device_node *np,
501 const char *list_name,
502 const char *cells_name)
503{
504 return -ENOSYS;
505}
506
Nicolas Ferreed5f8862011-10-27 11:07:28 +0200507static inline int of_alias_get_id(struct device_node *np, const char *stem)
508{
509 return -ENOSYS;
510}
511
Stephen Warren50e07f82011-10-25 14:01:26 +0200512static inline int of_machine_is_compatible(const char *compat)
513{
514 return 0;
515}
516
Sascha Hauer5c19e952013-08-05 14:40:44 +0200517static inline int of_device_is_stdout_path(struct device_node *dn)
518{
519 return 0;
520}
521
Sebastian Andrzej Siewior2adfffa2013-06-17 16:48:13 +0200522static inline const __be32 *of_prop_next_u32(struct property *prop,
523 const __be32 *cur, u32 *pu)
524{
525 return NULL;
526}
527
528static inline const char *of_prop_next_string(struct property *prop,
529 const char *cur)
530{
531 return NULL;
532}
533
Ben Dooks3a1e3622011-08-03 10:11:42 +0100534#define of_match_ptr(_ptr) NULL
Nicolas Ferre5762c202011-10-24 11:53:32 +0200535#define of_match_node(_matches, _node) NULL
Jeremy Kerr9dfbf202010-02-14 07:13:43 -0700536#endif /* CONFIG_OF */
Shawn Guob98c0232011-07-08 16:27:33 +0800537
Paul Mundt5ca4db62012-06-03 22:04:34 -0700538#ifndef of_node_to_nid
539static inline int of_node_to_nid(struct device_node *np)
540{
541 return numa_node_id();
542}
543
544#define of_node_to_nid of_node_to_nid
545#endif
546
Jean-Christophe PLAGNIOL-VILLARDfa4d34c2012-02-07 12:12:51 +0800547/**
548 * of_property_read_bool - Findfrom a property
549 * @np: device node from which the property value is to be read.
550 * @propname: name of the property to be searched.
551 *
552 * Search for a property in a device node.
553 * Returns true if the property exist false otherwise.
554 */
555static inline bool of_property_read_bool(const struct device_node *np,
556 const char *propname)
557{
558 struct property *prop = of_find_property(np, propname, NULL);
559
560 return prop ? true : false;
561}
562
Viresh Kumarbe193242012-11-20 10:15:19 +0530563static inline int of_property_read_u8(const struct device_node *np,
564 const char *propname,
565 u8 *out_value)
566{
567 return of_property_read_u8_array(np, propname, out_value, 1);
568}
569
570static inline int of_property_read_u16(const struct device_node *np,
571 const char *propname,
572 u16 *out_value)
573{
574 return of_property_read_u16_array(np, propname, out_value, 1);
575}
576
Shawn Guob98c0232011-07-08 16:27:33 +0800577static inline int of_property_read_u32(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100578 const char *propname,
Shawn Guob98c0232011-07-08 16:27:33 +0800579 u32 *out_value)
580{
581 return of_property_read_u32_array(np, propname, out_value, 1);
582}
583
Sebastian Andrzej Siewior2adfffa2013-06-17 16:48:13 +0200584#define of_property_for_each_u32(np, propname, prop, p, u) \
585 for (prop = of_find_property(np, propname, NULL), \
586 p = of_prop_next_u32(prop, NULL, &u); \
587 p; \
588 p = of_prop_next_u32(prop, p, &u))
589
590#define of_property_for_each_string(np, propname, prop, s) \
591 for (prop = of_find_property(np, propname, NULL), \
592 s = of_prop_next_string(prop, NULL); \
593 s; \
594 s = of_prop_next_string(prop, s))
595
David Howells34db8aa2013-04-12 02:29:19 +0100596#if defined(CONFIG_PROC_FS) && defined(CONFIG_PROC_DEVICETREE)
597extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
598extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
599extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
600 struct property *prop);
601extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
602 struct property *newprop,
603 struct property *oldprop);
604#endif
605
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000606#endif /* _LINUX_OF_H */