of.h 40.4 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0+ */
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef _LINUX_OF_H
#define _LINUX_OF_H
/*
 * Definitions for talking to the Open Firmware PROM on
 * Power Macintosh and other computers.
 *
 * Copyright (C) 1996-2005 Paul Mackerras.
 *
 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
 * Updates for SPARC64 by David S. Miller
 * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp.
 */
#include <linux/types.h>
Jiri Slaby's avatar
Jiri Slaby committed
15
#include <linux/bitops.h>
Kalle Valo's avatar
Kalle Valo committed
16
#include <linux/errno.h>
17
#include <linux/kobject.h>
18
#include <linux/mod_devicetable.h>
19
#include <linux/spinlock.h>
Paul Mundt's avatar
Paul Mundt committed
20
#include <linux/topology.h>
21
#include <linux/notifier.h>
22
#include <linux/property.h>
23
#include <linux/list.h>
24

25
#include <asm/byteorder.h>
26
#include <asm/errno.h>
27

28
29
30
31
32
33
34
35
typedef u32 phandle;
typedef u32 ihandle;

struct property {
	char	*name;
	int	length;
	void	*value;
	struct property *next;
36
#if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
37
	unsigned long _flags;
38
#endif
39
#if defined(CONFIG_OF_PROMTREE)
40
	unsigned int unique_id;
41
#endif
42
#if defined(CONFIG_OF_KOBJ)
43
	struct bin_attribute attr;
44
#endif
45
46
};

Grant Likely's avatar
Grant Likely committed
47
48
49
50
51
52
53
#if defined(CONFIG_SPARC)
struct of_irq_controller;
#endif

struct device_node {
	const char *name;
	const char *type;
54
	phandle phandle;
55
	const char *full_name;
56
	struct fwnode_handle fwnode;
Grant Likely's avatar
Grant Likely committed
57
58
59
60
61
62

	struct	property *properties;
	struct	property *deadprops;	/* removed properties */
	struct	device_node *parent;
	struct	device_node *child;
	struct	device_node *sibling;
63
#if defined(CONFIG_OF_KOBJ)
64
	struct	kobject kobj;
65
#endif
Grant Likely's avatar
Grant Likely committed
66
67
68
	unsigned long _flags;
	void	*data;
#if defined(CONFIG_SPARC)
69
	const char *path_component_name;
Grant Likely's avatar
Grant Likely committed
70
71
72
73
74
	unsigned int unique_id;
	struct of_irq_controller *irq_trans;
#endif
};

75
#define MAX_PHANDLE_ARGS 16
76
77
78
79
80
81
struct of_phandle_args {
	struct device_node *np;
	int args_count;
	uint32_t args[MAX_PHANDLE_ARGS];
};

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
struct of_phandle_iterator {
	/* Common iterator information */
	const char *cells_name;
	int cell_count;
	const struct device_node *parent;

	/* List size information */
	const __be32 *list_end;
	const __be32 *phandle_end;

	/* Current position state */
	const __be32 *cur;
	uint32_t cur_count;
	phandle phandle;
	struct device_node *node;
};

99
100
101
102
103
104
struct of_reconfig_data {
	struct device_node	*dn;
	struct property		*prop;
	struct property		*old_prop;
};

105
106
/* initialize a node */
extern struct kobj_type of_node_ktype;
107
extern const struct fwnode_operations of_fwnode_ops;
108
109
static inline void of_node_init(struct device_node *node)
{
110
#if defined(CONFIG_OF_KOBJ)
111
	kobject_init(&node->kobj, &of_node_ktype);
112
#endif
113
	node->fwnode.ops = &of_fwnode_ops;
114
115
}

116
#if defined(CONFIG_OF_KOBJ)
117
#define of_node_kobj(n) (&(n)->kobj)
118
119
120
#else
#define of_node_kobj(n) NULL
#endif
121

122
123
124
125
#ifdef CONFIG_OF_DYNAMIC
extern struct device_node *of_node_get(struct device_node *node);
extern void of_node_put(struct device_node *node);
#else /* CONFIG_OF_DYNAMIC */
126
127
128
129
130
/* Dummy ref counting routines - to be implemented later */
static inline struct device_node *of_node_get(struct device_node *node)
{
	return node;
}
131
132
static inline void of_node_put(struct device_node *node) { }
#endif /* !CONFIG_OF_DYNAMIC */
133

134
/* Pointer for first entry in chain of all nodes. */
Grant Likely's avatar
Grant Likely committed
135
extern struct device_node *of_root;
136
extern struct device_node *of_chosen;
137
extern struct device_node *of_aliases;
138
extern struct device_node *of_stdout;
139
extern raw_spinlock_t devtree_lock;
140

141
142
143
144
145
146
/* flag descriptions (need to be visible even when !CONFIG_OF) */
#define OF_DYNAMIC	1 /* node and properties were allocated via kmalloc */
#define OF_DETACHED	2 /* node has been detached from the device tree */
#define OF_POPULATED	3 /* device already created for the node */
#define OF_POPULATED_BUS	4 /* of_platform_populate recursed to children of this node */

147
148
#define OF_BAD_ADDR	((u64)-1)

149
#ifdef CONFIG_OF
150
151
void of_core_init(void);

152
static inline bool is_of_node(const struct fwnode_handle *fwnode)
153
{
154
	return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &of_fwnode_ops;
155
156
}

157
158
159
160
161
162
163
164
165
#define to_of_node(__fwnode)						\
	({								\
		typeof(__fwnode) __to_of_node_fwnode = (__fwnode);	\
									\
		is_of_node(__to_of_node_fwnode) ?			\
			container_of(__to_of_node_fwnode,		\
				     struct device_node, fwnode) :	\
			NULL;						\
	})
166

167
168
169
170
171
172
173
#define of_fwnode_handle(node)						\
	({								\
		typeof(node) __of_fwnode_handle_node = (node);		\
									\
		__of_fwnode_handle_node ?				\
			&__of_fwnode_handle_node->fwnode : NULL;	\
	})
174

175
176
static inline bool of_have_populated_dt(void)
{
Grant Likely's avatar
Grant Likely committed
177
	return of_root != NULL;
178
179
}

180
181
182
183
184
static inline bool of_node_is_root(const struct device_node *node)
{
	return node && (node->parent == NULL);
}

185
186
187
188
189
static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
{
	return test_bit(flag, &n->_flags);
}

190
191
192
193
194
195
static inline int of_node_test_and_set_flag(struct device_node *n,
					    unsigned long flag)
{
	return test_and_set_bit(flag, &n->_flags);
}

196
197
198
199
200
static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
{
	set_bit(flag, &n->_flags);
}

201
202
203
204
205
static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
{
	clear_bit(flag, &n->_flags);
}

206
#if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
207
208
209
210
211
212
213
214
215
216
217
218
219
220
static inline int of_property_check_flag(struct property *p, unsigned long flag)
{
	return test_bit(flag, &p->_flags);
}

static inline void of_property_set_flag(struct property *p, unsigned long flag)
{
	set_bit(flag, &p->_flags);
}

static inline void of_property_clear_flag(struct property *p, unsigned long flag)
{
	clear_bit(flag, &p->_flags);
}
221
#endif
222

Grant Likely's avatar
Grant Likely committed
223
extern struct device_node *__of_find_all_nodes(struct device_node *prev);
224
225
extern struct device_node *of_find_all_nodes(struct device_node *prev);

226
/*
Lennert Buytenhek's avatar
Lennert Buytenhek committed
227
 * OF address retrieval & translation
228
229
230
 */

/* Helper to read a big number; size is in cells (not bytes) */
231
static inline u64 of_read_number(const __be32 *cell, int size)
232
233
234
{
	u64 r = 0;
	while (size--)
235
		r = (r << 32) | be32_to_cpu(*(cell++));
236
237
238
239
	return r;
}

/* Like of_read_number, but we want an unsigned long result */
240
static inline unsigned long of_read_ulong(const __be32 *cell, int size)
241
{
242
243
	/* toss away upper bits if unsigned long is smaller than u64 */
	return of_read_number(cell, size);
244
245
}

Rob Herring's avatar
Rob Herring committed
246
#if defined(CONFIG_SPARC)
247
#include <asm/prom.h>
Rob Herring's avatar
Rob Herring committed
248
#endif
249

250
251
252
253
254
255
/* Default #address and #size cells.  Allow arch asm/prom.h to override */
#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
#endif

256
257
258
#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)

259
static inline const char *of_node_full_name(const struct device_node *np)
260
261
262
263
{
	return np ? np->full_name : "<no-node>";
}

Grant Likely's avatar
Grant Likely committed
264
265
266
#define for_each_of_allnodes_from(from, dn) \
	for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn))
#define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn)
267
268
269
270
271
272
extern struct device_node *of_find_node_by_name(struct device_node *from,
	const char *name);
extern struct device_node *of_find_node_by_type(struct device_node *from,
	const char *type);
extern struct device_node *of_find_compatible_node(struct device_node *from,
	const char *type, const char *compat);
273
274
275
276
extern struct device_node *of_find_matching_node_and_match(
	struct device_node *from,
	const struct of_device_id *matches,
	const struct of_device_id **match);
277

278
279
280
281
282
283
284
extern struct device_node *of_find_node_opts_by_path(const char *path,
	const char **opts);
static inline struct device_node *of_find_node_by_path(const char *path)
{
	return of_find_node_opts_by_path(path, NULL);
}

285
286
extern struct device_node *of_find_node_by_phandle(phandle handle);
extern struct device_node *of_get_parent(const struct device_node *node);
287
extern struct device_node *of_get_next_parent(struct device_node *node);
288
289
extern struct device_node *of_get_next_child(const struct device_node *node,
					     struct device_node *prev);
290
291
292
extern struct device_node *of_get_next_available_child(
	const struct device_node *node, struct device_node *prev);

293
294
extern struct device_node *of_get_compatible_child(const struct device_node *parent,
					const char *compatible);
295
296
extern struct device_node *of_get_child_by_name(const struct device_node *node,
					const char *name);
297

298
299
/* cache lookup */
extern struct device_node *of_find_next_cache_node(const struct device_node *);
300
extern int of_find_last_cache_level(unsigned int cpu);
301
302
303
extern struct device_node *of_find_node_with_property(
	struct device_node *from, const char *prop_name);

304
305
306
extern struct property *of_find_property(const struct device_node *np,
					 const char *name,
					 int *lenp);
307
308
extern int of_property_count_elems_of_size(const struct device_node *np,
				const char *propname, int elem_size);
309
310
311
extern int of_property_read_u32_index(const struct device_node *np,
				       const char *propname,
				       u32 index, u32 *out_value);
312
313
314
extern int of_property_read_u64_index(const struct device_node *np,
				       const char *propname,
				       u32 index, u64 *out_value);
315
316
317
318
319
320
321
322
323
324
325
extern int of_property_read_variable_u8_array(const struct device_node *np,
					const char *propname, u8 *out_values,
					size_t sz_min, size_t sz_max);
extern int of_property_read_variable_u16_array(const struct device_node *np,
					const char *propname, u16 *out_values,
					size_t sz_min, size_t sz_max);
extern int of_property_read_variable_u32_array(const struct device_node *np,
					const char *propname,
					u32 *out_values,
					size_t sz_min,
					size_t sz_max);
326
327
extern int of_property_read_u64(const struct device_node *np,
				const char *propname, u64 *out_value);
328
329
330
331
332
extern int of_property_read_variable_u64_array(const struct device_node *np,
					const char *propname,
					u64 *out_values,
					size_t sz_min,
					size_t sz_max);
333

334
extern int of_property_read_string(const struct device_node *np,
335
336
				   const char *propname,
				   const char **out_string);
337
extern int of_property_match_string(const struct device_node *np,
338
339
				    const char *propname,
				    const char *string);
340
extern int of_property_read_string_helper(const struct device_node *np,
341
342
					      const char *propname,
					      const char **out_strs, size_t sz, int index);
343
344
extern int of_device_is_compatible(const struct device_node *device,
				   const char *);
345
346
extern int of_device_compatible_match(struct device_node *device,
				      const char *const *compat);
347
extern bool of_device_is_available(const struct device_node *device);
348
extern bool of_device_is_big_endian(const struct device_node *device);
349
350
351
extern const void *of_get_property(const struct device_node *node,
				const char *name,
				int *lenp);
352
extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
353
354
#define for_each_property_of_node(dn, pp) \
	for (pp = dn->properties; pp != NULL; pp = pp->next)
355

356
357
extern int of_n_addr_cells(struct device_node *np);
extern int of_n_size_cells(struct device_node *np);
358
359
extern const struct of_device_id *of_match_node(
	const struct of_device_id *matches, const struct device_node *node);
360
extern int of_modalias_node(struct device_node *node, char *modalias, int len);
361
extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
362
extern struct device_node *of_parse_phandle(const struct device_node *np,
363
364
					    const char *phandle_name,
					    int index);
365
extern int of_parse_phandle_with_args(const struct device_node *np,
366
	const char *list_name, const char *cells_name, int index,
367
	struct of_phandle_args *out_args);
368
369
370
extern int of_parse_phandle_with_args_map(const struct device_node *np,
	const char *list_name, const char *stem_name, int index,
	struct of_phandle_args *out_args);
371
372
373
extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
	const char *list_name, int cells_count, int index,
	struct of_phandle_args *out_args);
374
375
extern int of_count_phandle_with_args(const struct device_node *np,
	const char *list_name, const char *cells_name);
376

377
378
379
380
381
382
383
/* phandle iterator functions */
extern int of_phandle_iterator_init(struct of_phandle_iterator *it,
				    const struct device_node *np,
				    const char *list_name,
				    const char *cells_name,
				    int cell_count);

384
extern int of_phandle_iterator_next(struct of_phandle_iterator *it);
385
386
387
extern int of_phandle_iterator_args(struct of_phandle_iterator *it,
				    uint32_t *args,
				    int size);
388

389
390
extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
extern int of_alias_get_id(struct device_node *np, const char *stem);
391
extern int of_alias_get_highest_id(const char *stem);
392

393
394
extern int of_machine_is_compatible(const char *compat);

395
396
397
extern int of_add_property(struct device_node *np, struct property *prop);
extern int of_remove_property(struct device_node *np, struct property *prop);
extern int of_update_property(struct device_node *np, struct property *newprop);
398

399
/* For updating the device tree at runtime */
400
401
402
403
404
405
406
407
#define OF_RECONFIG_ATTACH_NODE		0x0001
#define OF_RECONFIG_DETACH_NODE		0x0002
#define OF_RECONFIG_ADD_PROPERTY	0x0003
#define OF_RECONFIG_REMOVE_PROPERTY	0x0004
#define OF_RECONFIG_UPDATE_PROPERTY	0x0005

extern int of_attach_node(struct device_node *);
extern int of_detach_node(struct device_node *);
408

Ben Dooks's avatar
Ben Dooks committed
409
#define of_match_ptr(_ptr)	(_ptr)
410

411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
/**
 * of_property_read_u8_array - Find and read an array of u8 from a property.
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @out_values:	pointer to return value, modified only if return value is 0.
 * @sz:		number of array elements to read
 *
 * Search for a property in a device node and read 8-bit value(s) from
 * it. Returns 0 on success, -EINVAL if the property does not exist,
 * -ENODATA if property does not have a value, and -EOVERFLOW if the
 * property data isn't large enough.
 *
 * dts entry of array should be like:
 *	property = /bits/ 8 <0x50 0x60 0x70>;
 *
 * The out_values is modified only if a valid u8 value can be decoded.
 */
static inline int of_property_read_u8_array(const struct device_node *np,
					    const char *propname,
					    u8 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u8_array(np, propname, out_values,
						     sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

/**
 * of_property_read_u16_array - Find and read an array of u16 from a property.
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @out_values:	pointer to return value, modified only if return value is 0.
 * @sz:		number of array elements to read
 *
 * Search for a property in a device node and read 16-bit value(s) from
 * it. Returns 0 on success, -EINVAL if the property does not exist,
 * -ENODATA if property does not have a value, and -EOVERFLOW if the
 * property data isn't large enough.
 *
 * dts entry of array should be like:
 *	property = /bits/ 16 <0x5000 0x6000 0x7000>;
 *
 * The out_values is modified only if a valid u16 value can be decoded.
 */
static inline int of_property_read_u16_array(const struct device_node *np,
					     const char *propname,
					     u16 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u16_array(np, propname, out_values,
						      sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

/**
 * of_property_read_u32_array - Find and read an array of 32 bit integers
 * from a property.
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @out_values:	pointer to return value, modified only if return value is 0.
 * @sz:		number of array elements to read
 *
 * Search for a property in a device node and read 32-bit value(s) from
 * it. Returns 0 on success, -EINVAL if the property does not exist,
 * -ENODATA if property does not have a value, and -EOVERFLOW if the
 * property data isn't large enough.
 *
 * The out_values is modified only if a valid u32 value can be decoded.
 */
static inline int of_property_read_u32_array(const struct device_node *np,
					     const char *propname,
					     u32 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u32_array(np, propname, out_values,
						      sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

/**
 * of_property_read_u64_array - Find and read an array of 64 bit integers
 * from a property.
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @out_values:	pointer to return value, modified only if return value is 0.
 * @sz:		number of array elements to read
 *
 * Search for a property in a device node and read 64-bit value(s) from
 * it. Returns 0 on success, -EINVAL if the property does not exist,
 * -ENODATA if property does not have a value, and -EOVERFLOW if the
 * property data isn't large enough.
 *
 * The out_values is modified only if a valid u64 value can be decoded.
 */
static inline int of_property_read_u64_array(const struct device_node *np,
					     const char *propname,
					     u64 *out_values, size_t sz)
{
	int ret = of_property_read_variable_u64_array(np, propname, out_values,
						      sz, 0);
	if (ret >= 0)
		return 0;
	else
		return ret;
}

527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
/*
 * struct property *prop;
 * const __be32 *p;
 * u32 u;
 *
 * of_property_for_each_u32(np, "propname", prop, p, u)
 *         printk("U32 value: %x\n", u);
 */
const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
			       u32 *pu);
/*
 * struct property *prop;
 * const char *s;
 *
 * of_property_for_each_string(np, "propname", prop, s)
 *         printk("String value: %s\n", s);
 */
const char *of_prop_next_string(struct property *prop, const char *cur);

546
bool of_console_check(struct device_node *dn, char *name, int index);
547

548
549
extern int of_cpu_node_to_id(struct device_node *np);

550
#else /* CONFIG_OF */
551

552
553
554
555
static inline void of_core_init(void)
{
}

556
static inline bool is_of_node(const struct fwnode_handle *fwnode)
557
558
559
560
{
	return false;
}

561
static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode)
562
563
564
565
{
	return NULL;
}

566
static inline const char* of_node_full_name(const struct device_node *np)
567
568
569
570
{
	return "<no-node>";
}

571
572
573
574
575
576
static inline struct device_node *of_find_node_by_name(struct device_node *from,
	const char *name)
{
	return NULL;
}

577
578
static inline struct device_node *of_find_node_by_type(struct device_node *from,
	const char *type)
579
580
581
582
{
	return NULL;
}

583
584
585
586
static inline struct device_node *of_find_matching_node_and_match(
	struct device_node *from,
	const struct of_device_id *matches,
	const struct of_device_id **match)
587
{
588
	return NULL;
589
590
}

591
592
593
594
595
static inline struct device_node *of_find_node_by_path(const char *path)
{
	return NULL;
}

596
597
598
599
600
601
static inline struct device_node *of_find_node_opts_by_path(const char *path,
	const char **opts)
{
	return NULL;
}

602
603
604
605
606
static inline struct device_node *of_find_node_by_phandle(phandle handle)
{
	return NULL;
}

607
static inline struct device_node *of_get_parent(const struct device_node *node)
608
{
609
	return NULL;
610
611
}

612
613
614
615
616
static inline struct device_node *of_get_next_child(
	const struct device_node *node, struct device_node *prev)
{
	return NULL;
}
617

618
619
620
621
622
static inline struct device_node *of_get_next_available_child(
	const struct device_node *node, struct device_node *prev)
{
	return NULL;
}
623

624
625
static inline struct device_node *of_find_node_with_property(
	struct device_node *from, const char *prop_name)
626
627
628
629
{
	return NULL;
}

630
631
#define of_fwnode_handle(node) NULL

632
static inline bool of_have_populated_dt(void)
633
{
634
	return false;
635
636
}

637
638
639
640
641
642
static inline struct device_node *of_get_compatible_child(const struct device_node *parent,
					const char *compatible)
{
	return NULL;
}

643
644
645
static inline struct device_node *of_get_child_by_name(
					const struct device_node *node,
					const char *name)
646
{
647
	return NULL;
648
649
}

650
651
652
653
654
655
static inline int of_device_is_compatible(const struct device_node *device,
					  const char *name)
{
	return 0;
}

656
657
658
659
660
661
static inline  int of_device_compatible_match(struct device_node *device,
					      const char *const *compat)
{
	return 0;
}

662
static inline bool of_device_is_available(const struct device_node *device)
663
{
664
	return false;
665
666
}

667
668
669
static inline bool of_device_is_big_endian(const struct device_node *device)
{
	return false;
670
671
}

672
673
674
675
676
677
678
static inline struct property *of_find_property(const struct device_node *np,
						const char *name,
						int *lenp)
{
	return NULL;
}

679
680
681
682
683
684
685
686
static inline struct device_node *of_find_compatible_node(
						struct device_node *from,
						const char *type,
						const char *compat)
{
	return NULL;
}

687
688
689
690
691
692
static inline int of_property_count_elems_of_size(const struct device_node *np,
			const char *propname, int elem_size)
{
	return -ENOSYS;
}

693
694
695
696
697
698
699
700
701
702
703
704
static inline int of_property_read_u8_array(const struct device_node *np,
			const char *propname, u8 *out_values, size_t sz)
{
	return -ENOSYS;
}

static inline int of_property_read_u16_array(const struct device_node *np,
			const char *propname, u16 *out_values, size_t sz)
{
	return -ENOSYS;
}

705
static inline int of_property_read_u32_array(const struct device_node *np,
706
707
					     const char *propname,
					     u32 *out_values, size_t sz)
708
709
710
711
{
	return -ENOSYS;
}

712
713
714
715
716
717
718
static inline int of_property_read_u64_array(const struct device_node *np,
					     const char *propname,
					     u64 *out_values, size_t sz)
{
	return -ENOSYS;
}

719
720
static inline int of_property_read_u32_index(const struct device_node *np,
			const char *propname, u32 index, u32 *out_value)
721
722
723
724
{
	return -ENOSYS;
}

725
726
static inline int of_property_read_u64_index(const struct device_node *np,
			const char *propname, u32 index, u64 *out_value)
727
728
729
730
{
	return -ENOSYS;
}

731
732
733
734
735
736
737
static inline const void *of_get_property(const struct device_node *node,
				const char *name,
				int *lenp)
{
	return NULL;
}

738
739
740
741
742
743
static inline struct device_node *of_get_cpu_node(int cpu,
					unsigned int *thread)
{
	return NULL;
}

744
745
746
747
748
749
750
751
752
753
static inline int of_n_addr_cells(struct device_node *np)
{
	return 0;

}
static inline int of_n_size_cells(struct device_node *np)
{
	return 0;
}

754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
static inline int of_property_read_variable_u8_array(const struct device_node *np,
					const char *propname, u8 *out_values,
					size_t sz_min, size_t sz_max)
{
	return -ENOSYS;
}

static inline int of_property_read_variable_u16_array(const struct device_node *np,
					const char *propname, u16 *out_values,
					size_t sz_min, size_t sz_max)
{
	return -ENOSYS;
}

static inline int of_property_read_variable_u32_array(const struct device_node *np,
					const char *propname,
					u32 *out_values,
					size_t sz_min,
					size_t sz_max)
{
	return -ENOSYS;
}

777
778
779
780
781
782
static inline int of_property_read_u64(const struct device_node *np,
				       const char *propname, u64 *out_value)
{
	return -ENOSYS;
}

783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
static inline int of_property_read_variable_u64_array(const struct device_node *np,
					const char *propname,
					u64 *out_values,
					size_t sz_min,
					size_t sz_max)
{
	return -ENOSYS;
}

static inline int of_property_read_string(const struct device_node *np,
					  const char *propname,
					  const char **out_string)
{
	return -ENOSYS;
}

799
static inline int of_property_match_string(const struct device_node *np,
800
801
802
803
804
805
					   const char *propname,
					   const char *string)
{
	return -ENOSYS;
}

806
807
808
809
810
811
812
static inline int of_property_read_string_helper(const struct device_node *np,
						 const char *propname,
						 const char **out_strs, size_t sz, int index)
{
	return -ENOSYS;
}

813
static inline struct device_node *of_parse_phandle(const struct device_node *np,
814
815
816
817
818
819
						   const char *phandle_name,
						   int index)
{
	return NULL;
}

820
static inline int of_parse_phandle_with_args(const struct device_node *np,
821
822
823
824
825
826
827
828
					     const char *list_name,
					     const char *cells_name,
					     int index,
					     struct of_phandle_args *out_args)
{
	return -ENOSYS;
}

829
830
831
832
833
834
835
836
837
static inline int of_parse_phandle_with_args_map(const struct device_node *np,
						 const char *list_name,
						 const char *stem_name,
						 int index,
						 struct of_phandle_args *out_args)
{
	return -ENOSYS;
}

838
839
840
841
842
843
844
static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
	const char *list_name, int cells_count, int index,
	struct of_phandle_args *out_args)
{
	return -ENOSYS;
}

845
846
847
848
849
850
851
static inline int of_count_phandle_with_args(struct device_node *np,
					     const char *list_name,
					     const char *cells_name)
{
	return -ENOSYS;
}

852
853
854
855
856
857
858
859
860
static inline int of_phandle_iterator_init(struct of_phandle_iterator *it,
					   const struct device_node *np,
					   const char *list_name,
					   const char *cells_name,
					   int cell_count)
{
	return -ENOSYS;
}

861
862
863
864
865
static inline int of_phandle_iterator_next(struct of_phandle_iterator *it)
{
	return -ENOSYS;
}

866
867
868
869
870
871
872
static inline int of_phandle_iterator_args(struct of_phandle_iterator *it,
					   uint32_t *args,
					   int size)
{
	return 0;
}

873
874
875
876
877
static inline int of_alias_get_id(struct device_node *np, const char *stem)
{
	return -ENOSYS;
}

878
879
880
881
882
static inline int of_alias_get_highest_id(const char *stem)
{
	return -ENOSYS;
}

883
884
885
886
887
static inline int of_machine_is_compatible(const char *compat)
{
	return 0;
}

888
static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
889
{
890
	return false;
891
892
}

893
894
895
896
897
898
899
900
901
902
903
904
static inline const __be32 *of_prop_next_u32(struct property *prop,
		const __be32 *cur, u32 *pu)
{
	return NULL;
}

static inline const char *of_prop_next_string(struct property *prop,
		const char *cur)
{
	return NULL;
}

905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
{
	return 0;
}

static inline int of_node_test_and_set_flag(struct device_node *n,
					    unsigned long flag)
{
	return 0;
}

static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
{
}

static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
{
}

static inline int of_property_check_flag(struct property *p, unsigned long flag)
{
	return 0;
}

static inline void of_property_set_flag(struct property *p, unsigned long flag)
{
}

static inline void of_property_clear_flag(struct property *p, unsigned long flag)
{
}

937
938
939
940
941
static inline int of_cpu_node_to_id(struct device_node *np)
{
	return -ENODEV;
}

Ben Dooks's avatar
Ben Dooks committed
942
#define of_match_ptr(_ptr)	NULL
943
#define of_match_node(_matches, _node)	NULL
944
#endif /* CONFIG_OF */
945

946
947
948
949
950
951
952
/* Default string compare functions, Allow arch asm/prom.h to override */
#if !defined(of_compat_cmp)
#define of_compat_cmp(s1, s2, l)	strcasecmp((s1), (s2))
#define of_prop_cmp(s1, s2)		strcmp((s1), (s2))
#define of_node_cmp(s1, s2)		strcasecmp((s1), (s2))
#endif

953
954
955
#if defined(CONFIG_OF) && defined(CONFIG_NUMA)
extern int of_node_to_nid(struct device_node *np);
#else
956
957
958
959
static inline int of_node_to_nid(struct device_node *device)
{
	return NUMA_NO_NODE;
}
Paul Mundt's avatar
Paul Mundt committed
960
961
#endif

962
963
964
965
966
967
968
969
970
#ifdef CONFIG_OF_NUMA
extern int of_numa_init(void);
#else
static inline int of_numa_init(void)
{
	return -ENOSYS;
}
#endif

971
972
973
974
975
976
977
static inline struct device_node *of_find_matching_node(
	struct device_node *from,
	const struct of_device_id *matches)
{
	return of_find_matching_node_and_match(from, matches, NULL);
}

978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
/**
 * of_property_count_u8_elems - Count the number of u8 elements in a property
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 *
 * Search for a property in a device node and count the number of u8 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u8 and -ENODATA if the
 * property does not have a value.
 */
static inline int of_property_count_u8_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u8));
}

/**
 * of_property_count_u16_elems - Count the number of u16 elements in a property
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 *
 * Search for a property in a device node and count the number of u16 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u16 and -ENODATA if the
 * property does not have a value.
 */
static inline int of_property_count_u16_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u16));
}

/**
 * of_property_count_u32_elems - Count the number of u32 elements in a property
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 *
 * Search for a property in a device node and count the number of u32 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u32 and -ENODATA if the
 * property does not have a value.
 */
static inline int of_property_count_u32_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u32));
}

/**
 * of_property_count_u64_elems - Count the number of u64 elements in a property
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 *
 * Search for a property in a device node and count the number of u64 elements
 * in it. Returns number of elements on sucess, -EINVAL if the property does
 * not exist or its length does not match a multiple of u64 and -ENODATA if the
 * property does not have a value.
 */
static inline int of_property_count_u64_elems(const struct device_node *np,
				const char *propname)
{
	return of_property_count_elems_of_size(np, propname, sizeof(u64));
}

1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
/**
 * of_property_read_string_array() - Read an array of strings from a multiple
 * strings property.
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @out_strs:	output array of string pointers.
 * @sz:		number of array elements to read.
 *
 * Search for a property in a device tree node and retrieve a list of
 * terminated string values (pointer to data, not a copy) in that property.
 *
 * If @out_strs is NULL, the number of strings in the property is returned.
 */
1059
static inline int of_property_read_string_array(const struct device_node *np,
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
						const char *propname, const char **out_strs,
						size_t sz)
{
	return of_property_read_string_helper(np, propname, out_strs, sz, 0);
}

/**
 * of_property_count_strings() - Find and return the number of strings from a
 * multiple strings property.
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 *
 * Search for a property in a device tree node and retrieve the number of null
 * terminated string contain in it. Returns the number of strings on
 * success, -EINVAL if the property does not exist, -ENODATA if property
 * does not have a value, and -EILSEQ if the string is not null-terminated
 * within the length of the property data.
 */
1078
static inline int of_property_count_strings(const struct device_node *np,
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
					    const char *propname)
{
	return of_property_read_string_helper(np, propname, NULL, 0, 0);
}

/**
 * of_property_read_string_index() - Find and read a string from a multiple
 * strings property.
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @index:	index of the string in the list of strings
 * @out_string:	pointer to null terminated return string, modified only if
 *		return value is 0.
 *
 * Search for a property in a device tree node and retrieve a null
 * terminated string value (pointer to data, not a copy) in the list of strings
 * contained in that property.
 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
 * property does not have a value, and -EILSEQ if the string is not
 * null-terminated within the length of the property data.
 *
 * The out_string pointer is modified only if a valid string can be decoded.
 */
1102
static inline int of_property_read_string_index(const struct device_node *np,
1103
1104
1105
1106
1107
1108
1109
						const char *propname,
						int index, const char **output)
{
	int rc = of_property_read_string_helper(np, propname, output, 1, index);
	return rc < 0 ? rc : 0;
}

1110
1111
1112
1113
1114
1115
/**
 * of_property_read_bool - Findfrom a property
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 *
 * Search for a property in a device node.
1116
 * Returns true if the property exists false otherwise.
1117
1118
1119
1120
1121
1122
1123
1124
1125
 */
static inline bool of_property_read_bool(const struct device_node *np,
					 const char *propname)
{
	struct property *prop = of_find_property(np, propname, NULL);

	return prop ? true : false;
}

1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
static inline int of_property_read_u8(const struct device_node *np,
				       const char *propname,
				       u8 *out_value)
{
	return of_property_read_u8_array(np, propname, out_value, 1);
}

static inline int of_property_read_u16(const struct device_node *np,
				       const char *propname,
				       u16 *out_value)
{
	return of_property_read_u16_array(np, propname, out_value, 1);
}

1140
static inline int of_property_read_u32(const struct device_node *np,
1141
				       const char *propname,
1142
1143
1144
1145
1146
				       u32 *out_value)
{
	return of_property_read_u32_array(np, propname, out_value, 1);
}

1147
1148
1149
1150
1151
1152
1153
static inline int of_property_read_s32(const struct device_node *np,
				       const char *propname,
				       s32 *out_value)
{
	return of_property_read_u32(np, propname, (u32*) out_value);
}

1154
1155
1156
1157
1158
1159
#define of_for_each_phandle(it, err, np, ln, cn, cc)			\
	for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)),	\
	     err = of_phandle_iterator_next(it);			\
	     err == 0;							\
	     err = of_phandle_iterator_next(it))

1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
#define of_property_for_each_u32(np, propname, prop, p, u)	\
	for (prop = of_find_property(np, propname, NULL),	\
		p = of_prop_next_u32(prop, NULL, &u);		\
		p;						\
		p = of_prop_next_u32(prop, p, &u))

#define of_property_for_each_string(np, propname, prop, s)	\
	for (prop = of_find_property(np, propname, NULL),	\
		s = of_prop_next_string(prop, NULL);		\
		s;						\
		s = of_prop_next_string(prop, s))

1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
#define for_each_node_by_name(dn, name) \
	for (dn = of_find_node_by_name(NULL, name); dn; \
	     dn = of_find_node_by_name(dn, name))
#define for_each_node_by_type(dn, type) \
	for (dn = of_find_node_by_type(NULL, type); dn; \
	     dn = of_find_node_by_type(dn, type))
#define for_each_compatible_node(dn, type, compatible) \
	for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
	     dn = of_find_compatible_node(dn, type, compatible))
#define for_each_matching_node(dn, matches) \
	for (dn = of_find_matching_node(NULL, matches); dn; \
	     dn = of_find_matching_node(dn, matches))
#define for_each_matching_node_and_match(dn, matches, match) \
	for (dn = of_find_matching_node_and_match(NULL, matches, match); \
	     dn; dn = of_find_matching_node_and_match(dn, matches, match))

#define for_each_child_of_node(parent, child) \
	for (child = of_get_next_child(parent, NULL); child != NULL; \
	     child = of_get_next_child(parent, child))
#define for_each_available_child_of_node(parent, child) \
	for (child = of_get_next_available_child(parent, NULL); child != NULL; \
	     child = of_get_next_available_child(parent, child))

#define for_each_node_with_property(dn, prop_name) \
	for (dn = of_find_node_with_property(NULL, prop_name); dn; \
	     dn = of_find_node_with_property(dn, prop_name))

static inline int of_get_child_count(const struct device_node *np)
{
	struct device_node *child;
	int num = 0;

	for_each_child_of_node(np, child)
		num++;

	return num;
}

static inline int of_get_available_child_count(const struct device_node *np)
{
	struct device_node *child;
	int num = 0;

	for_each_available_child_of_node(np, child)
		num++;

	return num;
}

1221
#if defined(CONFIG_OF) && !defined(MODULE)
1222
1223
1224
1225
1226
1227
#define _OF_DECLARE(table, name, compat, fn, fn_type)			\
	static const struct of_device_id __of_table_##name		\
		__used __section(__##table##_of_table)			\
		 = { .compatible = compat,				\
		     .data = (fn == (fn_type)NULL) ? fn : fn  }
#else
1228
#define _OF_DECLARE(table, name, compat, fn, fn_type)			\
1229
1230
1231
1232
1233
1234
1235
	static const struct of_device_id __of_table_##name		\
		__attribute__((unused))					\
		 = { .compatible = compat,				\
		     .data = (fn == (fn_type)NULL) ? fn : fn }
#endif

typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
1236
typedef int (*of_init_fn_1_ret)(struct device_node *);
1237
1238
1239
1240
typedef void (*of_init_fn_1)(struct device_node *);

#define OF_DECLARE_1(table, name, compat, fn) \
		_OF_DECLARE(table, name, compat, fn, of_init_fn_1)
1241
1242
#define OF_DECLARE_1_RET(table, name, compat, fn) \
		_OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret)
1243
1244
1245
#define OF_DECLARE_2(table, name, compat, fn) \
		_OF_DECLARE(table, name, compat, fn, of_init_fn_2)

1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
/**
 * struct of_changeset_entry	- Holds a changeset entry
 *
 * @node:	list_head for the log list
 * @action:	notifier action
 * @np:		pointer to the device node affected
 * @prop:	pointer to the property affected
 * @old_prop:	hold a pointer to the original property
 *
 * Every modification of the device tree during a changeset
 * is held in a list of of_changeset_entry structures.
 * That way we can recover from a partial application, or we can
 * revert the changeset
 */
struct of_changeset_entry {
	struct list_head node;
	unsigned long action;
	struct device_node *np;
	struct property *prop;
	struct property *old_prop;
};

/**
 * struct of_changeset - changeset tracker structure
 *
 * @entries:	list_head for the changeset entries
 *
 * changesets are a convenient way to apply bulk changes to the
 * live tree. In case of an error, changes are rolled-back.
 * changesets live on after initial application, and if not
 * destroyed after use, they can be reverted in one single call.
 */
struct of_changeset {
	struct list_head entries;
};

1282
1283
1284
1285
1286
1287
enum of_reconfig_change {
	OF_RECONFIG_NO_CHANGE = 0,
	OF_RECONFIG_CHANGE_ADD,
	OF_RECONFIG_CHANGE_REMOVE,
};

1288
#ifdef CONFIG_OF_DYNAMIC
1289
1290
extern int of_reconfig_notifier_register(struct notifier_block *);
extern int of_reconfig_notifier_unregister(struct notifier_block *);
1291
1292
1293
extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
extern int of_reconfig_get_state_change(unsigned long action,
					struct of_reconfig_data *arg);
1294

1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
extern void of_changeset_init(struct of_changeset *ocs);
extern void of_changeset_destroy(struct of_changeset *ocs);
extern int of_changeset_apply(struct of_changeset *ocs);
extern int of_changeset_revert(struct of_changeset *ocs);
extern int of_changeset_action(struct of_changeset *ocs,
		unsigned long action, struct device_node *np,
		struct property *prop);

static inline int of_changeset_attach_node(struct of_changeset *ocs,
		struct device_node *np)
{
	return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
}

static inline int of_changeset_detach_node(struct of_changeset *ocs,
		struct device_node *np)
{
	return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
}

static inline int of_changeset_add_property(struct of_changeset *ocs,
		struct device_node *np, struct property *prop)
{
	return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
}

static inline int of_changeset_remove_property(struct of_changeset *ocs,
		struct device_node *np, struct property *prop)
{
	return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
}

static inline int of_changeset_update_property(struct of_changeset *ocs,
		struct device_node *np, struct property *prop)
{
	return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
}
1332
1333
1334
1335
1336
1337
1338
1339
1340
#else /* CONFIG_OF_DYNAMIC */
static inline int of_reconfig_notifier_register(struct notifier_block *nb)
{
	return -EINVAL;
}
static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
{
	return -EINVAL;
}
1341
1342
static inline int of_reconfig_notify(unsigned long action,
				     struct of_reconfig_data *arg)
1343
1344
1345
{
	return -EINVAL;
}
1346
1347
static inline int of_reconfig_get_state_change(unsigned long action,
						struct of_reconfig_data *arg)
1348
1349
1350
1351
{
	return -EINVAL;
}
#endif /* CONFIG_OF_DYNAMIC */
1352

1353
/**
1354
 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node
1355
1356
1357
1358
 * @np: Pointer to the given device_node
 *
 * return true if present false otherwise
 */
1359
static inline bool of_device_is_system_power_controller(const struct device_node *np)
1360
{
1361
	return of_property_read_bool(np, "system-power-controller");
1362
1363
}

1364
1365
1366
1367
/**
 * Overlay support
 */

1368
enum of_overlay_notify_action {
1369
	OF_OVERLAY_PRE_APPLY = 0,
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
	OF_OVERLAY_POST_APPLY,
	OF_OVERLAY_PRE_REMOVE,
	OF_OVERLAY_POST_REMOVE,
};

struct of_overlay_notify_data {
	struct device_node *overlay;
	struct device_node *target;
};

1380
1381
#ifdef CONFIG_OF_OVERLAY

1382
1383
int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size,
			 int *ovcs_id);
1384
int of_overlay_remove(int *ovcs_id);
1385
int of_overlay_remove_all(void);
1386

1387
1388
1389
int of_overlay_notifier_register(struct notifier_block *nb);
int of_overlay_notifier_unregister(struct notifier_block *nb);

1390
1391
#else

1392
static inline int of_overlay_fdt_apply(void *overlay_fdt, int *ovcs_id)
1393
1394
1395
1396
{
	return -ENOTSUPP;
}

1397
static inline int of_overlay_remove(int *ovcs_id)
1398
1399
1400
1401
{
	return -ENOTSUPP;
}

1402
static inline int of_overlay_remove_all(void)
1403
1404
1405
1406
{
	return -ENOTSUPP;
}

1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
static inline int of_overlay_notifier_register(struct notifier_block *nb)
{
	return 0;
}

static inline int of_overlay_notifier_unregister(struct notifier_block *nb)
{
	return 0;
}

1417
1418
#endif

1419
#endif /* _LINUX_OF_H */