blob: 276c546980d81fec5867a3126cc2bb73575ed769 [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
Rob Herringb5b4bb32013-09-07 14:08:20 -0500139#if defined(CONFIG_SPARC)
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000140#include <asm/prom.h>
Rob Herringb5b4bb32013-09-07 14:08:20 -0500141#endif
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000142
Grant Likely7c7b60c2010-02-14 07:13:50 -0700143/* 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)
Grant Likely19761522010-03-18 07:30:31 -0600151#define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
Grant Likely7c7b60c2010-02-14 07:13:50 -0700152#define of_prop_cmp(s1, s2) strcmp((s1), (s2))
153#define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
154#endif
155
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000156/* 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
Grant Likely61e955d2009-10-15 10:57:51 -0600160#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
161#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
162
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000163#define OF_BAD_ADDR ((u64)-1)
164
Steffen Trumtrarc0a05bf2012-12-18 11:32:03 +0100165static inline const char *of_node_full_name(const struct device_node *np)
Grant Likely74a7f082012-06-15 11:50:25 -0600166{
167 return np ? np->full_name : "<no-node>";
168}
169
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000170extern 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))
175extern 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))
180extern 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))
Stephen Warren50c8af42012-11-20 16:12:20 -0700185extern 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);
189static inline struct device_node *of_find_matching_node(
190 struct device_node *from,
191 const struct of_device_id *matches)
192{
193 return of_find_matching_node_and_match(from, matches, NULL);
194}
Grant Likely283029d2008-01-09 06:20:40 +1100195#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))
Stephen Warren50c8af42012-11-20 16:12:20 -0700198#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))
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000201extern struct device_node *of_find_node_by_path(const char *path);
202extern struct device_node *of_find_node_by_phandle(phandle handle);
203extern struct device_node *of_get_parent(const struct device_node *node);
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000204extern struct device_node *of_get_next_parent(struct device_node *node);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000205extern struct device_node *of_get_next_child(const struct device_node *node,
206 struct device_node *prev);
Timur Tabi32961932012-08-14 13:20:23 +0000207extern struct device_node *of_get_next_available_child(
208 const struct device_node *node, struct device_node *prev);
209
Srinivas Kandagatla9c197612012-09-18 08:10:28 +0100210extern struct device_node *of_get_child_by_name(const struct device_node *node,
211 const char *name);
Michael Ellermanaabc08d2007-11-26 19:03:45 +1100212#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
Timur Tabi32961932012-08-14 13:20:23 +0000216#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
Dong Aisheng183f1d02012-04-27 11:36:20 +0800220static 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
Bryan Wu954e04b2013-09-24 10:38:26 -0700231static inline int of_get_available_child_count(const struct device_node *np)
232{
233 struct device_node *child;
234 int num = 0;
235
236 for_each_available_child_of_node(np, child)
237 num++;
238
239 return num;
240}
241
Sudeep KarkadaNageshaa3e31b42013-09-18 11:53:05 +0100242/* cache lookup */
243extern struct device_node *of_find_next_cache_node(const struct device_node *);
Michael Ellerman1e291b12008-11-12 18:54:42 +0000244extern 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
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000250extern struct property *of_find_property(const struct device_node *np,
251 const char *name,
252 int *lenp);
Tony Prisk3daf3722013-03-23 17:02:15 +1300253extern int of_property_read_u32_index(const struct device_node *np,
254 const char *propname,
255 u32 index, u32 *out_value);
Viresh Kumarbe193242012-11-20 10:15:19 +0530256extern int of_property_read_u8_array(const struct device_node *np,
257 const char *propname, u8 *out_values, size_t sz);
258extern int of_property_read_u16_array(const struct device_node *np,
259 const char *propname, u16 *out_values, size_t sz);
Rob Herring0e373632011-07-06 15:42:58 -0500260extern int of_property_read_u32_array(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100261 const char *propname,
Rob Herring0e373632011-07-06 15:42:58 -0500262 u32 *out_values,
263 size_t sz);
Jamie Iles4cd7f7a2011-09-14 20:49:59 +0100264extern int of_property_read_u64(const struct device_node *np,
265 const char *propname, u64 *out_value);
Rob Herring0e373632011-07-06 15:42:58 -0500266
Jamie Ilesaac285c2011-08-02 15:45:07 +0100267extern int of_property_read_string(struct device_node *np,
268 const char *propname,
269 const char **out_string);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200270extern int of_property_read_string_index(struct device_node *np,
271 const char *propname,
272 int index, const char **output);
Grant Likely7aff0fe2011-12-12 09:25:58 -0700273extern int of_property_match_string(struct device_node *np,
274 const char *propname,
275 const char *string);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200276extern int of_property_count_strings(struct device_node *np,
277 const char *propname);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000278extern int of_device_is_compatible(const struct device_node *device,
279 const char *);
Josh Boyer834d97d2008-03-27 00:33:14 +1100280extern int of_device_is_available(const struct device_node *device);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000281extern const void *of_get_property(const struct device_node *node,
282 const char *name,
283 int *lenp);
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100284extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
Dong Aisheng8af0da92011-12-22 20:19:24 +0800285#define for_each_property_of_node(dn, pp) \
286 for (pp = dn->properties; pp != NULL; pp = pp->next)
Shawn Guo611cad72011-08-15 15:28:14 +0800287
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000288extern int of_n_addr_cells(struct device_node *np);
289extern int of_n_size_cells(struct device_node *np);
Grant Likely283029d2008-01-09 06:20:40 +1100290extern const struct of_device_id *of_match_node(
291 const struct of_device_id *matches, const struct device_node *node);
Grant Likely3f07af42008-07-25 22:25:13 -0400292extern int of_modalias_node(struct device_node *node, char *modalias, int len);
Grant Likely624cfca2013-10-11 22:05:10 +0100293extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
Steffen Trumtrarb8fbdc42012-11-22 12:16:43 +0100294extern struct device_node *of_parse_phandle(const struct device_node *np,
Grant Likely739649c2009-04-25 12:52:40 +0000295 const char *phandle_name,
296 int index);
Guennadi Liakhovetski93c667c2012-12-10 20:41:30 +0100297extern int of_parse_phandle_with_args(const struct device_node *np,
Anton Vorontsov64b60e02008-10-10 04:43:17 +0000298 const char *list_name, const char *cells_name, int index,
Grant Likely15c9a0a2011-12-12 09:25:57 -0700299 struct of_phandle_args *out_args);
Stephen Warren035fd942013-08-14 15:27:10 -0600300extern 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);
Grant Likelybd69f732013-02-10 22:57:21 +0000303extern int of_count_phandle_with_args(const struct device_node *np,
304 const char *list_name, const char *cells_name);
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000305
Shawn Guo611cad72011-08-15 15:28:14 +0800306extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
307extern int of_alias_get_id(struct device_node *np, const char *stem);
308
Grant Likely21b082e2010-02-14 07:13:38 -0700309extern int of_machine_is_compatible(const char *compat);
310
Nathan Fontenot79d1c712012-10-02 16:58:46 +0000311extern int of_add_property(struct device_node *np, struct property *prop);
312extern int of_remove_property(struct device_node *np, struct property *prop);
313extern int of_update_property(struct device_node *np, struct property *newprop);
Grant Likely21b082e2010-02-14 07:13:38 -0700314
Grant Likelyfcdeb7f2010-01-29 05:04:33 -0700315/* For updating the device tree at runtime */
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +0000316#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
322struct of_prop_reconfig {
323 struct device_node *dn;
324 struct property *prop;
325};
326
327extern int of_reconfig_notifier_register(struct notifier_block *);
328extern int of_reconfig_notifier_unregister(struct notifier_block *);
329extern int of_reconfig_notify(unsigned long, void *);
330
331extern int of_attach_node(struct device_node *);
332extern int of_detach_node(struct device_node *);
Grant Likelyfcdeb7f2010-01-29 05:04:33 -0700333
Ben Dooks3a1e3622011-08-03 10:11:42 +0100334#define of_match_ptr(_ptr) (_ptr)
Stephen Warrenc541adc2012-04-04 09:27:46 -0600335
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 */
344const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
345 u32 *pu);
Stephen Warrenc541adc2012-04-04 09:27:46 -0600346/*
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 */
353const char *of_prop_next_string(struct property *prop, const char *cur);
Stephen Warrenc541adc2012-04-04 09:27:46 -0600354
Sascha Hauer5c19e952013-08-05 14:40:44 +0200355int of_device_is_stdout_path(struct device_node *dn);
356
Shawn Guob98c0232011-07-08 16:27:33 +0800357#else /* CONFIG_OF */
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +0100358
Grant Likely74a7f082012-06-15 11:50:25 -0600359static inline const char* of_node_full_name(struct device_node *np)
360{
361 return "<no-node>";
362}
363
Peter Ujfalusi1cc44f42012-09-10 13:46:24 +0300364static inline struct device_node *of_find_node_by_name(struct device_node *from,
365 const char *name)
366{
367 return NULL;
368}
369
Alexander Shiyan066ec1d2013-04-09 19:47:40 +0400370static inline struct device_node *of_get_parent(const struct device_node *node)
371{
372 return NULL;
373}
374
Sebastian Andrzej Siewior3bcbaf62011-02-22 21:07:46 +0100375static inline bool of_have_populated_dt(void)
376{
377 return false;
378}
379
Stephen Warrenaba3dff2011-09-21 13:23:10 -0600380#define for_each_child_of_node(parent, child) \
381 while (0)
382
Sylwester Nawrockif6f07472013-10-28 13:12:35 -0500383#define for_each_available_child_of_node(parent, child) \
384 while (0)
385
Olof Johansson25c040c2012-10-07 10:40:54 -0700386static 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
Dong Aisheng183f1d02012-04-27 11:36:20 +0800393static inline int of_get_child_count(const struct device_node *np)
394{
395 return 0;
396}
397
Bryan Wu954e04b2013-09-24 10:38:26 -0700398static inline int of_get_available_child_count(const struct device_node *np)
399{
400 return 0;
401}
402
Rajendra Nayak36a09042011-10-10 21:49:35 +0530403static inline int of_device_is_compatible(const struct device_node *device,
404 const char *name)
405{
406 return 0;
407}
408
Rob Herringd7195692013-03-20 16:56:18 -0500409static inline int of_device_is_available(const struct device_node *device)
410{
411 return 0;
412}
413
Stephen Warrenaba3dff2011-09-21 13:23:10 -0600414static inline struct property *of_find_property(const struct device_node *np,
415 const char *name,
416 int *lenp)
417{
418 return NULL;
419}
420
Shawn Guo2261cc62012-02-15 10:47:42 -0800421static 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
Tony Prisk3daf3722013-03-23 17:02:15 +1300429static 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
Viresh Kumarbe193242012-11-20 10:15:19 +0530435static 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
441static 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
Shawn Guob98c0232011-07-08 16:27:33 +0800447static inline int of_property_read_u32_array(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100448 const char *propname,
449 u32 *out_values, size_t sz)
Shawn Guob98c0232011-07-08 16:27:33 +0800450{
451 return -ENOSYS;
452}
453
454static inline int of_property_read_string(struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100455 const char *propname,
456 const char **out_string)
Shawn Guob98c0232011-07-08 16:27:33 +0800457{
458 return -ENOSYS;
459}
460
Benoit Cousson4fcd15a2011-09-27 17:45:43 +0200461static 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
468static inline int of_property_count_strings(struct device_node *np,
469 const char *propname)
470{
471 return -ENOSYS;
472}
473
Stephen Warren89272b82011-08-05 16:50:30 -0600474static inline const void *of_get_property(const struct device_node *node,
475 const char *name,
476 int *lenp)
477{
478 return NULL;
479}
480
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100481static inline struct device_node *of_get_cpu_node(int cpu,
482 unsigned int *thread)
483{
484 return NULL;
485}
486
Jamie Iles4cd7f7a2011-09-14 20:49:59 +0100487static inline int of_property_read_u64(const struct device_node *np,
488 const char *propname, u64 *out_value)
489{
490 return -ENOSYS;
491}
492
Thierry Redingbd3d5502012-04-13 16:18:34 +0200493static inline int of_property_match_string(struct device_node *np,
494 const char *propname,
495 const char *string)
496{
497 return -ENOSYS;
498}
499
Steffen Trumtrarb8fbdc42012-11-22 12:16:43 +0100500static inline struct device_node *of_parse_phandle(const struct device_node *np,
Rajendra Nayak36a09042011-10-10 21:49:35 +0530501 const char *phandle_name,
502 int index)
503{
504 return NULL;
505}
506
Thierry Redinge05e5072012-04-13 16:19:21 +0200507static 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
Stephen Warren035fd942013-08-14 15:27:10 -0600516static 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
Grant Likelybd69f732013-02-10 22:57:21 +0000523static 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
Nicolas Ferreed5f8862011-10-27 11:07:28 +0200530static inline int of_alias_get_id(struct device_node *np, const char *stem)
531{
532 return -ENOSYS;
533}
534
Stephen Warren50e07f82011-10-25 14:01:26 +0200535static inline int of_machine_is_compatible(const char *compat)
536{
537 return 0;
538}
539
Sascha Hauer5c19e952013-08-05 14:40:44 +0200540static inline int of_device_is_stdout_path(struct device_node *dn)
541{
542 return 0;
543}
544
Sebastian Andrzej Siewior2adfffa2013-06-17 16:48:13 +0200545static inline const __be32 *of_prop_next_u32(struct property *prop,
546 const __be32 *cur, u32 *pu)
547{
548 return NULL;
549}
550
551static inline const char *of_prop_next_string(struct property *prop,
552 const char *cur)
553{
554 return NULL;
555}
556
Ben Dooks3a1e3622011-08-03 10:11:42 +0100557#define of_match_ptr(_ptr) NULL
Nicolas Ferre5762c202011-10-24 11:53:32 +0200558#define of_match_node(_matches, _node) NULL
Jeremy Kerr9dfbf202010-02-14 07:13:43 -0700559#endif /* CONFIG_OF */
Shawn Guob98c0232011-07-08 16:27:33 +0800560
Rob Herring0c3f0612013-09-17 10:42:50 -0500561#if defined(CONFIG_OF) && defined(CONFIG_NUMA)
562extern int of_node_to_nid(struct device_node *np);
563#else
564static inline int of_node_to_nid(struct device_node *device) { return 0; }
Paul Mundt5ca4db62012-06-03 22:04:34 -0700565#endif
566
Jean-Christophe PLAGNIOL-VILLARDfa4d34c2012-02-07 12:12:51 +0800567/**
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 */
575static inline bool of_property_read_bool(const struct device_node *np,
576 const char *propname)
577{
578 struct property *prop = of_find_property(np, propname, NULL);
579
580 return prop ? true : false;
581}
582
Viresh Kumarbe193242012-11-20 10:15:19 +0530583static 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
590static 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
Shawn Guob98c0232011-07-08 16:27:33 +0800597static inline int of_property_read_u32(const struct device_node *np,
Jamie Ilesaac285c2011-08-02 15:45:07 +0100598 const char *propname,
Shawn Guob98c0232011-07-08 16:27:33 +0800599 u32 *out_value)
600{
601 return of_property_read_u32_array(np, propname, out_value, 1);
602}
603
Sebastian Andrzej Siewior2adfffa2013-06-17 16:48:13 +0200604#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
David Howells34db8aa2013-04-12 02:29:19 +0100616#if defined(CONFIG_PROC_FS) && defined(CONFIG_PROC_DEVICETREE)
617extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
618extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
619extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
620 struct property *prop);
621extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
622 struct property *newprop,
623 struct property *oldprop);
624#endif
625
Stephen Rothwell76c1ce72007-05-01 16:19:07 +1000626#endif /* _LINUX_OF_H */