base.c 65.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
/*
 * Procedures for creating, accessing and interpreting the device tree.
 *
 * Paul Mackerras	August 1996.
 * Copyright (C) 1996-2005 Paul Mackerras.
 *
 *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
 *    {engebret|bergner}@us.ibm.com
 *
 *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
 *
12
13
 *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
 *  Grant Likely.
14
15
16
17
18
19
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */
20
21
22

#define pr_fmt(fmt)	"OF: " fmt

23
#include <linux/console.h>
24
#include <linux/ctype.h>
25
#include <linux/cpu.h>
26
27
#include <linux/module.h>
#include <linux/of.h>
28
#include <linux/of_graph.h>
29
#include <linux/spinlock.h>
30
#include <linux/slab.h>
31
#include <linux/string.h>
Jeremy Kerr's avatar
Jeremy Kerr committed
32
#include <linux/proc_fs.h>
33

34
#include "of_private.h"
35

36
LIST_HEAD(aliases_lookup);
37

Grant Likely's avatar
Grant Likely committed
38
39
struct device_node *of_root;
EXPORT_SYMBOL(of_root);
40
struct device_node *of_chosen;
41
struct device_node *of_aliases;
42
struct device_node *of_stdout;
43
static const char *of_stdout_options;
44

45
struct kset *of_kset;
46
47

/*
48
49
50
51
 * Used to protect the of_aliases, to hold off addition of nodes to sysfs.
 * This mutex must be held whenever modifications are being made to the
 * device tree. The of_{attach,detach}_node() and
 * of_{add,remove,update}_property() helpers make sure this happens.
52
 */
53
DEFINE_MUTEX(of_mutex);
54

Grant Likely's avatar
Grant Likely committed
55
/* use when traversing tree through the child, sibling,
56
57
 * or parent members of struct device_node.
 */
58
DEFINE_RAW_SPINLOCK(devtree_lock);
59
60
61

int of_n_addr_cells(struct device_node *np)
{
62
	const __be32 *ip;
63
64
65
66
67
68

	do {
		if (np->parent)
			np = np->parent;
		ip = of_get_property(np, "#address-cells", NULL);
		if (ip)
69
			return be32_to_cpup(ip);
70
71
72
73
74
75
76
77
	} while (np->parent);
	/* No #address-cells property for the root node */
	return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
}
EXPORT_SYMBOL(of_n_addr_cells);

int of_n_size_cells(struct device_node *np)
{
78
	const __be32 *ip;
79
80
81
82
83
84

	do {
		if (np->parent)
			np = np->parent;
		ip = of_get_property(np, "#size-cells", NULL);
		if (ip)
85
			return be32_to_cpup(ip);
86
87
88
89
90
91
	} while (np->parent);
	/* No #size-cells property for the root node */
	return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
}
EXPORT_SYMBOL(of_n_size_cells);

92
93
94
#ifdef CONFIG_NUMA
int __weak of_node_to_nid(struct device_node *np)
{
95
	return NUMA_NO_NODE;
96
97
98
}
#endif

99
#ifndef CONFIG_OF_DYNAMIC
100
101
102
103
static void of_node_release(struct kobject *kobj)
{
	/* Without CONFIG_OF_DYNAMIC, no nodes gets freed */
}
104
#endif /* CONFIG_OF_DYNAMIC */
105

106
107
108
109
110
111
112
113
114
115
116
117
struct kobj_type of_node_ktype = {
	.release = of_node_release,
};

static ssize_t of_node_property_read(struct file *filp, struct kobject *kobj,
				struct bin_attribute *bin_attr, char *buf,
				loff_t offset, size_t count)
{
	struct property *pp = container_of(bin_attr, struct property, attr);
	return memory_read_from_buffer(buf, count, &offset, pp->value, pp->length);
}

118
/* always return newly allocated name, caller must free after use */
119
120
121
122
123
124
125
126
127
128
129
130
131
132
static const char *safe_name(struct kobject *kobj, const char *orig_name)
{
	const char *name = orig_name;
	struct kernfs_node *kn;
	int i = 0;

	/* don't be a hero. After 16 tries give up */
	while (i < 16 && (kn = sysfs_get_dirent(kobj->sd, name))) {
		sysfs_put(kn);
		if (name != orig_name)
			kfree(name);
		name = kasprintf(GFP_KERNEL, "%s#%i", orig_name, ++i);
	}

133
134
135
	if (name == orig_name) {
		name = kstrdup(orig_name, GFP_KERNEL);
	} else {
136
		pr_warn("Duplicate name in %s, renamed to \"%s\"\n",
137
			kobject_name(kobj), name);
138
	}
139
140
141
	return name;
}

142
int __of_add_property_sysfs(struct device_node *np, struct property *pp)
143
144
145
146
147
148
{
	int rc;

	/* Important: Don't leak passwords */
	bool secure = strncmp(pp->name, "security-", 9) == 0;

149
150
151
	if (!IS_ENABLED(CONFIG_SYSFS))
		return 0;

152
153
154
	if (!of_kset || !of_node_is_attached(np))
		return 0;

155
156
157
158
159
160
161
162
163
164
165
	sysfs_bin_attr_init(&pp->attr);
	pp->attr.attr.name = safe_name(&np->kobj, pp->name);
	pp->attr.attr.mode = secure ? S_IRUSR : S_IRUGO;
	pp->attr.size = secure ? 0 : pp->length;
	pp->attr.read = of_node_property_read;

	rc = sysfs_create_bin_file(&np->kobj, &pp->attr);
	WARN(rc, "error adding attribute %s to node %s\n", pp->name, np->full_name);
	return rc;
}

166
int __of_attach_node_sysfs(struct device_node *np)
167
168
{
	const char *name;
169
	struct kobject *parent;
170
171
172
	struct property *pp;
	int rc;

173
174
175
	if (!IS_ENABLED(CONFIG_SYSFS))
		return 0;

176
177
178
	if (!of_kset)
		return 0;

179
180
181
	np->kobj.kset = of_kset;
	if (!np->parent) {
		/* Nodes without parents are new top level trees */
182
183
		name = safe_name(&of_kset->kobj, "base");
		parent = NULL;
184
185
	} else {
		name = safe_name(&np->parent->kobj, kbasename(np->full_name));
186
		parent = &np->parent->kobj;
187
	}
188
189
190
191
	if (!name)
		return -ENOMEM;
	rc = kobject_add(&np->kobj, parent, "%s", name);
	kfree(name);
192
193
194
195
196
197
198
199
200
	if (rc)
		return rc;

	for_each_property_of_node(np, pp)
		__of_add_property_sysfs(np, pp);

	return 0;
}

201
void __init of_core_init(void)
202
203
204
205
{
	struct device_node *np;

	/* Create the kset, and register existing nodes */
206
	mutex_lock(&of_mutex);
207
208
	of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
	if (!of_kset) {
209
		mutex_unlock(&of_mutex);
210
		pr_err("failed to register existing nodes\n");
211
		return;
212
213
	}
	for_each_of_allnodes(np)
214
		__of_attach_node_sysfs(np);
215
	mutex_unlock(&of_mutex);
216

Grant Likely's avatar
Grant Likely committed
217
	/* Symlink in /proc as required by userspace ABI */
Grant Likely's avatar
Grant Likely committed
218
	if (of_root)
219
220
221
		proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
}

222
223
static struct property *__of_find_property(const struct device_node *np,
					   const char *name, int *lenp)
224
225
226
{
	struct property *pp;

227
228
229
	if (!np)
		return NULL;

230
	for (pp = np->properties; pp; pp = pp->next) {
231
		if (of_prop_cmp(pp->name, name) == 0) {
232
			if (lenp)
233
234
235
236
				*lenp = pp->length;
			break;
		}
	}
237
238
239
240
241
242
243
244
245

	return pp;
}

struct property *of_find_property(const struct device_node *np,
				  const char *name,
				  int *lenp)
{
	struct property *pp;
246
	unsigned long flags;
247

248
	raw_spin_lock_irqsave(&devtree_lock, flags);
249
	pp = __of_find_property(np, name, lenp);
250
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
251
252
253
254
255

	return pp;
}
EXPORT_SYMBOL(of_find_property);

Grant Likely's avatar
Grant Likely committed
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
struct device_node *__of_find_all_nodes(struct device_node *prev)
{
	struct device_node *np;
	if (!prev) {
		np = of_root;
	} else if (prev->child) {
		np = prev->child;
	} else {
		/* Walk back up looking for a sibling, or the end of the structure */
		np = prev;
		while (np->parent && !np->sibling)
			np = np->parent;
		np = np->sibling; /* Might be null at the end of the tree */
	}
	return np;
}

273
274
275
276
277
278
279
280
281
282
283
/**
 * of_find_all_nodes - Get next node in global list
 * @prev:	Previous node or NULL to start iteration
 *		of_node_put() will be called on it
 *
 * Returns a node pointer with refcount incremented, use
 * of_node_put() on it when done.
 */
struct device_node *of_find_all_nodes(struct device_node *prev)
{
	struct device_node *np;
284
	unsigned long flags;
285

286
	raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely's avatar
Grant Likely committed
287
288
	np = __of_find_all_nodes(prev);
	of_node_get(np);
289
	of_node_put(prev);
290
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
291
292
293
294
	return np;
}
EXPORT_SYMBOL(of_find_all_nodes);

295
296
297
298
/*
 * Find a property with a given name for a given node
 * and return the value.
 */
299
300
const void *__of_get_property(const struct device_node *np,
			      const char *name, int *lenp)
301
302
303
304
305
306
{
	struct property *pp = __of_find_property(np, name, lenp);

	return pp ? pp->value : NULL;
}

307
308
309
310
311
/*
 * Find a property with a given name for a given node
 * and return the value.
 */
const void *of_get_property(const struct device_node *np, const char *name,
312
			    int *lenp)
313
314
315
316
317
318
{
	struct property *pp = of_find_property(np, name, lenp);

	return pp ? pp->value : NULL;
}
EXPORT_SYMBOL(of_get_property);
319

320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
/*
 * arch_match_cpu_phys_id - Match the given logical CPU and physical id
 *
 * @cpu: logical cpu index of a core/thread
 * @phys_id: physical identifier of a core/thread
 *
 * CPU logical to physical index mapping is architecture specific.
 * However this __weak function provides a default match of physical
 * id to logical cpu index. phys_id provided here is usually values read
 * from the device tree which must match the hardware internal registers.
 *
 * Returns true if the physical identifier and the logical cpu index
 * correspond to the same core/thread, false otherwise.
 */
bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
{
	return (u32)phys_id == cpu;
}

/**
 * Checks if the given "prop_name" property holds the physical id of the
 * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
 * NULL, local thread number within the core is returned in it.
 */
static bool __of_find_n_match_cpu_property(struct device_node *cpun,
			const char *prop_name, int cpu, unsigned int *thread)
{
	const __be32 *cell;
	int ac, prop_len, tid;
	u64 hwid;

	ac = of_n_addr_cells(cpun);
	cell = of_get_property(cpun, prop_name, &prop_len);
353
	if (!cell || !ac)
354
		return false;
355
	prop_len /= sizeof(*cell) * ac;
356
357
358
359
360
361
362
363
364
365
366
367
	for (tid = 0; tid < prop_len; tid++) {
		hwid = of_read_number(cell, ac);
		if (arch_match_cpu_phys_id(cpu, hwid)) {
			if (thread)
				*thread = tid;
			return true;
		}
		cell += ac;
	}
	return false;
}

368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
/*
 * arch_find_n_match_cpu_physical_id - See if the given device node is
 * for the cpu corresponding to logical cpu 'cpu'.  Return true if so,
 * else false.  If 'thread' is non-NULL, the local thread number within the
 * core is returned in it.
 */
bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun,
					      int cpu, unsigned int *thread)
{
	/* Check for non-standard "ibm,ppc-interrupt-server#s" property
	 * for thread ids on PowerPC. If it doesn't exist fallback to
	 * standard "reg" property.
	 */
	if (IS_ENABLED(CONFIG_PPC) &&
	    __of_find_n_match_cpu_property(cpun,
					   "ibm,ppc-interrupt-server#s",
					   cpu, thread))
		return true;

387
	return __of_find_n_match_cpu_property(cpun, "reg", cpu, thread);
388
389
}

390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
/**
 * of_get_cpu_node - Get device node associated with the given logical CPU
 *
 * @cpu: CPU number(logical index) for which device node is required
 * @thread: if not NULL, local thread number within the physical core is
 *          returned
 *
 * The main purpose of this function is to retrieve the device node for the
 * given logical CPU index. It should be used to initialize the of_node in
 * cpu device. Once of_node in cpu device is populated, all the further
 * references can use that instead.
 *
 * CPU logical to physical index mapping is architecture specific and is built
 * before booting secondary cores. This function uses arch_match_cpu_phys_id
 * which can be overridden by architecture specific implementation.
 *
406
407
 * Returns a node pointer for the logical cpu with refcount incremented, use
 * of_node_put() on it when done. Returns NULL if not found.
408
409
410
 */
struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
{
411
	struct device_node *cpun;
412

413
414
	for_each_node_by_type(cpun, "cpu") {
		if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
415
416
417
418
419
420
			return cpun;
	}
	return NULL;
}
EXPORT_SYMBOL(of_get_cpu_node);

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
/**
 * __of_device_is_compatible() - Check if the node matches given constraints
 * @device: pointer to node
 * @compat: required compatible string, NULL or "" for any match
 * @type: required device_type value, NULL or "" for any match
 * @name: required node name, NULL or "" for any match
 *
 * Checks if the given @compat, @type and @name strings match the
 * properties of the given @device. A constraints can be skipped by
 * passing NULL or an empty string as the constraint.
 *
 * Returns 0 for no match, and a positive integer on match. The return
 * value is a relative score with larger values indicating better
 * matches. The score is weighted for the most specific compatible value
 * to get the highest score. Matching type is next, followed by matching
 * name. Practically speaking, this results in the following priority
 * order for matches:
 *
 * 1. specific compatible && type && name
 * 2. specific compatible && type
 * 3. specific compatible && name
 * 4. specific compatible
 * 5. general compatible && type && name
 * 6. general compatible && type
 * 7. general compatible && name
 * 8. general compatible
 * 9. type && name
 * 10. type
 * 11. name
450
 */
451
static int __of_device_is_compatible(const struct device_node *device,
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
				     const char *compat, const char *type, const char *name)
{
	struct property *prop;
	const char *cp;
	int index = 0, score = 0;

	/* Compatible match has highest priority */
	if (compat && compat[0]) {
		prop = __of_find_property(device, "compatible", NULL);
		for (cp = of_prop_next_string(prop, NULL); cp;
		     cp = of_prop_next_string(prop, cp), index++) {
			if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
				score = INT_MAX/2 - (index << 2);
				break;
			}
		}
		if (!score)
			return 0;
	}
471

472
473
474
475
476
	/* Matching type is better than matching name */
	if (type && type[0]) {
		if (!device->type || of_node_cmp(type, device->type))
			return 0;
		score += 2;
477
478
	}

479
480
481
482
483
484
485
486
	/* Matching name is a bit better than not */
	if (name && name[0]) {
		if (!device->name || of_node_cmp(name, device->name))
			return 0;
		score++;
	}

	return score;
487
}
488
489
490
491
492
493
494

/** Checks if the given "compat" string matches one of the strings in
 * the device's "compatible" property
 */
int of_device_is_compatible(const struct device_node *device,
		const char *compat)
{
495
	unsigned long flags;
496
497
	int res;

498
	raw_spin_lock_irqsave(&devtree_lock, flags);
499
	res = __of_device_is_compatible(device, compat, NULL, NULL);
500
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
501
502
	return res;
}
503
EXPORT_SYMBOL(of_device_is_compatible);
Stephen Rothwell's avatar
Stephen Rothwell committed
504

505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
/** Checks if the device is compatible with any of the entries in
 *  a NULL terminated array of strings. Returns the best match
 *  score or 0.
 */
int of_device_compatible_match(struct device_node *device,
			       const char *const *compat)
{
	unsigned int tmp, score = 0;

	if (!compat)
		return 0;

	while (*compat) {
		tmp = of_device_is_compatible(device, *compat);
		if (tmp > score)
			score = tmp;
		compat++;
	}

	return score;
}

527
/**
528
 * of_machine_is_compatible - Test root of device tree for a given compatible value
529
530
 * @compat: compatible string to look for in root node's compatible property.
 *
531
 * Returns a positive integer if the root node has the given value in its
532
533
 * compatible property.
 */
534
int of_machine_is_compatible(const char *compat)
535
536
537
538
539
540
541
542
543
544
545
{
	struct device_node *root;
	int rc = 0;

	root = of_find_node_by_path("/");
	if (root) {
		rc = of_device_is_compatible(root, compat);
		of_node_put(root);
	}
	return rc;
}
546
EXPORT_SYMBOL(of_machine_is_compatible);
547

548
/**
549
 *  __of_device_is_available - check if a device is available for use
550
 *
551
 *  @device: Node to check for availability, with locks already held
552
 *
553
554
 *  Returns true if the status property is absent or set to "okay" or "ok",
 *  false otherwise
555
 */
556
static bool __of_device_is_available(const struct device_node *device)
557
558
559
560
{
	const char *status;
	int statlen;

561
	if (!device)
562
		return false;
563

564
	status = __of_get_property(device, "status", &statlen);
565
	if (status == NULL)
566
		return true;
567
568
569

	if (statlen > 0) {
		if (!strcmp(status, "okay") || !strcmp(status, "ok"))
570
			return true;
571
572
	}

573
	return false;
574
}
575
576
577
578
579
580

/**
 *  of_device_is_available - check if a device is available for use
 *
 *  @device: Node to check for availability
 *
581
582
 *  Returns true if the status property is absent or set to "okay" or "ok",
 *  false otherwise
583
 */
584
bool of_device_is_available(const struct device_node *device)
585
586
{
	unsigned long flags;
587
	bool res;
588
589
590
591
592
593
594

	raw_spin_lock_irqsave(&devtree_lock, flags);
	res = __of_device_is_available(device);
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
	return res;

}
595
596
EXPORT_SYMBOL(of_device_is_available);

597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
/**
 *  of_device_is_big_endian - check if a device has BE registers
 *
 *  @device: Node to check for endianness
 *
 *  Returns true if the device has a "big-endian" property, or if the kernel
 *  was compiled for BE *and* the device has a "native-endian" property.
 *  Returns false otherwise.
 *
 *  Callers would nominally use ioread32be/iowrite32be if
 *  of_device_is_big_endian() == true, or readl/writel otherwise.
 */
bool of_device_is_big_endian(const struct device_node *device)
{
	if (of_property_read_bool(device, "big-endian"))
		return true;
	if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&
	    of_property_read_bool(device, "native-endian"))
		return true;
	return false;
}
EXPORT_SYMBOL(of_device_is_big_endian);

Stephen Rothwell's avatar
Stephen Rothwell committed
620
621
622
623
624
625
626
627
628
629
/**
 *	of_get_parent - Get a node's parent if any
 *	@node:	Node to get parent
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
struct device_node *of_get_parent(const struct device_node *node)
{
	struct device_node *np;
630
	unsigned long flags;
Stephen Rothwell's avatar
Stephen Rothwell committed
631
632
633
634

	if (!node)
		return NULL;

635
	raw_spin_lock_irqsave(&devtree_lock, flags);
Stephen Rothwell's avatar
Stephen Rothwell committed
636
	np = of_node_get(node->parent);
637
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwell's avatar
Stephen Rothwell committed
638
639
640
	return np;
}
EXPORT_SYMBOL(of_get_parent);
641

642
643
644
645
/**
 *	of_get_next_parent - Iterate to a node's parent
 *	@node:	Node to get parent of
 *
646
647
648
 *	This is like of_get_parent() except that it drops the
 *	refcount on the passed node, making it suitable for iterating
 *	through a node's parents.
649
650
651
652
653
654
655
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
struct device_node *of_get_next_parent(struct device_node *node)
{
	struct device_node *parent;
656
	unsigned long flags;
657
658
659
660

	if (!node)
		return NULL;

661
	raw_spin_lock_irqsave(&devtree_lock, flags);
662
663
	parent = of_node_get(node->parent);
	of_node_put(node);
664
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
665
666
	return parent;
}
667
EXPORT_SYMBOL(of_get_next_parent);
668

669
670
671
672
673
static struct device_node *__of_get_next_child(const struct device_node *node,
						struct device_node *prev)
{
	struct device_node *next;

674
675
676
	if (!node)
		return NULL;

677
678
679
680
681
682
683
684
685
686
687
	next = prev ? prev->sibling : node->child;
	for (; next; next = next->sibling)
		if (of_node_get(next))
			break;
	of_node_put(prev);
	return next;
}
#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))

688
689
690
691
692
/**
 *	of_get_next_child - Iterate a node childs
 *	@node:	parent node
 *	@prev:	previous child of the parent node, or NULL to get first
 *
693
694
695
 *	Returns a node pointer with refcount incremented, use of_node_put() on
 *	it when done. Returns NULL when prev is the last child. Decrements the
 *	refcount of prev.
696
697
698
699
700
 */
struct device_node *of_get_next_child(const struct device_node *node,
	struct device_node *prev)
{
	struct device_node *next;
701
	unsigned long flags;
702

703
	raw_spin_lock_irqsave(&devtree_lock, flags);
704
	next = __of_get_next_child(node, prev);
705
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
706
707
708
	return next;
}
EXPORT_SYMBOL(of_get_next_child);
709

710
711
712
713
714
715
716
717
718
719
720
721
/**
 *	of_get_next_available_child - Find the next available child node
 *	@node:	parent node
 *	@prev:	previous child of the parent node, or NULL to get first
 *
 *      This function is like of_get_next_child(), except that it
 *      automatically skips any disabled nodes (i.e. status = "disabled").
 */
struct device_node *of_get_next_available_child(const struct device_node *node,
	struct device_node *prev)
{
	struct device_node *next;
722
	unsigned long flags;
723

724
725
726
	if (!node)
		return NULL;

727
	raw_spin_lock_irqsave(&devtree_lock, flags);
728
729
	next = prev ? prev->sibling : node->child;
	for (; next; next = next->sibling) {
730
		if (!__of_device_is_available(next))
731
732
733
734
735
			continue;
		if (of_node_get(next))
			break;
	}
	of_node_put(prev);
736
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
737
738
739
740
	return next;
}
EXPORT_SYMBOL(of_get_next_available_child);

741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
/**
 *	of_get_child_by_name - Find the child node by name for a given parent
 *	@node:	parent node
 *	@name:	child name to look for.
 *
 *      This function looks for child node for given matching name
 *
 *	Returns a node pointer if found, with refcount incremented, use
 *	of_node_put() on it when done.
 *	Returns NULL if node is not found.
 */
struct device_node *of_get_child_by_name(const struct device_node *node,
				const char *name)
{
	struct device_node *child;

	for_each_child_of_node(node, child)
		if (child->name && (of_node_cmp(child->name, name) == 0))
			break;
	return child;
}
EXPORT_SYMBOL(of_get_child_by_name);

764
765
766
767
static struct device_node *__of_find_node_by_path(struct device_node *parent,
						const char *path)
{
	struct device_node *child;
768
	int len;
769

770
	len = strcspn(path, "/:");
771
772
773
774
775
776
777
778
779
780
781
782
783
784
	if (!len)
		return NULL;

	__for_each_child_of_node(parent, child) {
		const char *name = strrchr(child->full_name, '/');
		if (WARN(!name, "malformed device_node %s\n", child->full_name))
			continue;
		name++;
		if (strncmp(path, name, len) == 0 && (strlen(name) == len))
			return child;
	}
	return NULL;
}

785
/**
786
 *	of_find_node_opts_by_path - Find a node matching a full OF path
787
788
789
790
 *	@path: Either the full path to match, or if the path does not
 *	       start with '/', the name of a property of the /aliases
 *	       node (an alias).  In the case of an alias, the node
 *	       matching the alias' value will be returned.
791
792
793
 *	@opts: Address of a pointer into which to store the start of
 *	       an options string appended to the end of the path with
 *	       a ':' separator.
794
795
796
797
798
 *
 *	Valid paths:
 *		/foo/bar	Full path
 *		foo		Valid alias
 *		foo/bar		Valid alias + relative path
799
800
801
802
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
803
struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
804
{
805
806
	struct device_node *np = NULL;
	struct property *pp;
807
	unsigned long flags;
808
809
810
811
	const char *separator = strchr(path, ':');

	if (opts)
		*opts = separator ? separator + 1 : NULL;
812

813
	if (strcmp(path, "/") == 0)
Grant Likely's avatar
Grant Likely committed
814
		return of_node_get(of_root);
815
816
817

	/* The path could begin with an alias */
	if (*path != '/') {
818
819
820
821
822
823
		int len;
		const char *p = separator;

		if (!p)
			p = strchrnul(path, '/');
		len = p - path;
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840

		/* of_aliases must not be NULL */
		if (!of_aliases)
			return NULL;

		for_each_property_of_node(of_aliases, pp) {
			if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) {
				np = of_find_node_by_path(pp->value);
				break;
			}
		}
		if (!np)
			return NULL;
		path = p;
	}

	/* Step down the tree matching path components */
841
	raw_spin_lock_irqsave(&devtree_lock, flags);
842
	if (!np)
Grant Likely's avatar
Grant Likely committed
843
		np = of_node_get(of_root);
844
845
846
847
	while (np && *path == '/') {
		path++; /* Increment past '/' delimiter */
		np = __of_find_node_by_path(np, path);
		path = strchrnul(path, '/');
848
849
		if (separator && separator < path)
			break;
850
	}
851
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
852
853
	return np;
}
854
EXPORT_SYMBOL(of_find_node_opts_by_path);
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870

/**
 *	of_find_node_by_name - Find a node by its "name" property
 *	@from:	The node to start searching from or NULL, the node
 *		you pass will not be searched, only the next one
 *		will; typically, you pass what the previous call
 *		returned. of_node_put() will be called on it
 *	@name:	The name string to match against
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
struct device_node *of_find_node_by_name(struct device_node *from,
	const char *name)
{
	struct device_node *np;
871
	unsigned long flags;
872

873
	raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely's avatar
Grant Likely committed
874
	for_each_of_allnodes_from(from, np)
875
876
877
878
		if (np->name && (of_node_cmp(np->name, name) == 0)
		    && of_node_get(np))
			break;
	of_node_put(from);
879
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
	return np;
}
EXPORT_SYMBOL(of_find_node_by_name);

/**
 *	of_find_node_by_type - Find a node by its "device_type" property
 *	@from:	The node to start searching from, or NULL to start searching
 *		the entire device tree. The node you pass will not be
 *		searched, only the next one will; typically, you pass
 *		what the previous call returned. of_node_put() will be
 *		called on from for you.
 *	@type:	The type string to match against
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
struct device_node *of_find_node_by_type(struct device_node *from,
	const char *type)
{
	struct device_node *np;
900
	unsigned long flags;
901

902
	raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely's avatar
Grant Likely committed
903
	for_each_of_allnodes_from(from, np)
904
905
906
907
		if (np->type && (of_node_cmp(np->type, type) == 0)
		    && of_node_get(np))
			break;
	of_node_put(from);
908
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
	return np;
}
EXPORT_SYMBOL(of_find_node_by_type);

/**
 *	of_find_compatible_node - Find a node based on type and one of the
 *                                tokens in its "compatible" property
 *	@from:		The node to start searching from or NULL, the node
 *			you pass will not be searched, only the next one
 *			will; typically, you pass what the previous call
 *			returned. of_node_put() will be called on it
 *	@type:		The type string to match "device_type" or NULL to ignore
 *	@compatible:	The string to match to one of the tokens in the device
 *			"compatible" list.
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
struct device_node *of_find_compatible_node(struct device_node *from,
	const char *type, const char *compatible)
{
	struct device_node *np;
931
	unsigned long flags;
932

933
	raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely's avatar
Grant Likely committed
934
	for_each_of_allnodes_from(from, np)
935
		if (__of_device_is_compatible(np, compatible, type, NULL) &&
936
		    of_node_get(np))
937
938
			break;
	of_node_put(from);
939
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
940
941
942
	return np;
}
EXPORT_SYMBOL(of_find_compatible_node);
943

944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
/**
 *	of_find_node_with_property - Find a node which has a property with
 *                                   the given name.
 *	@from:		The node to start searching from or NULL, the node
 *			you pass will not be searched, only the next one
 *			will; typically, you pass what the previous call
 *			returned. of_node_put() will be called on it
 *	@prop_name:	The name of the property to look for.
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
struct device_node *of_find_node_with_property(struct device_node *from,
	const char *prop_name)
{
	struct device_node *np;
	struct property *pp;
961
	unsigned long flags;
962

963
	raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely's avatar
Grant Likely committed
964
	for_each_of_allnodes_from(from, np) {
965
		for (pp = np->properties; pp; pp = pp->next) {
966
967
968
969
970
971
972
973
			if (of_prop_cmp(pp->name, prop_name) == 0) {
				of_node_get(np);
				goto out;
			}
		}
	}
out:
	of_node_put(from);
974
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
975
976
977
978
	return np;
}
EXPORT_SYMBOL(of_find_node_with_property);

979
980
981
static
const struct of_device_id *__of_match_node(const struct of_device_id *matches,
					   const struct device_node *node)
982
{
983
984
985
	const struct of_device_id *best_match = NULL;
	int score, best_score = 0;

986
987
988
	if (!matches)
		return NULL;

989
990
991
992
993
994
995
	for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
		score = __of_device_is_compatible(node, matches->compatible,
						  matches->type, matches->name);
		if (score > best_score) {
			best_match = matches;
			best_score = score;
		}
996
	}
997
998

	return best_match;
999
}
1000
1001

/**
Geert Uytterhoeven's avatar
Geert Uytterhoeven committed
1002
 * of_match_node - Tell if a device_node has a matching of_match structure
1003
1004
1005
 *	@matches:	array of of device match structures to search in
 *	@node:		the of device structure to match against
 *
1006
 *	Low level utility function used by device matching.
1007
1008
1009
1010
1011
 */
const struct of_device_id *of_match_node(const struct of_device_id *matches,
					 const struct device_node *node)
{
	const struct of_device_id *match;
1012
	unsigned long flags;
1013

1014
	raw_spin_lock_irqsave(&devtree_lock, flags);
1015
	match = __of_match_node(matches, node);
1016
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1017
1018
	return match;
}
1019
1020
1021
EXPORT_SYMBOL(of_match_node);

/**
1022
1023
 *	of_find_matching_node_and_match - Find a node based on an of_device_id
 *					  match table.
1024
1025
1026
1027
1028
 *	@from:		The node to start searching from or NULL, the node
 *			you pass will not be searched, only the next one
 *			will; typically, you pass what the previous call
 *			returned. of_node_put() will be called on it
 *	@matches:	array of of device match structures to search in
1029
 *	@match		Updated to point at the matches entry which matched
1030
1031
1032
1033
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.
 */
1034
1035
1036
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)
1037
1038
{
	struct device_node *np;
1039
	const struct of_device_id *m;
1040
	unsigned long flags;
1041

1042
1043
1044
	if (match)
		*match = NULL;

1045
	raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely's avatar
Grant Likely committed
1046
	for_each_of_allnodes_from(from, np) {
1047
		m = __of_match_node(matches, np);
1048
		if (m && of_node_get(np)) {
1049
			if (match)
1050
				*match = m;
1051
			break;
1052
		}
1053
1054
	}
	of_node_put(from);
1055
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1056
1057
	return np;
}
1058
EXPORT_SYMBOL(of_find_matching_node_and_match);
1059
1060
1061
1062
1063
1064
1065

/**
 * of_modalias_node - Lookup appropriate modalias for a device node
 * @node:	pointer to a device tree node
 * @modalias:	Pointer to buffer that modalias value will be copied into
 * @len:	Length of modalias value
 *
1066
1067
1068
1069
 * Based on the value of the compatible property, this routine will attempt
 * to choose an appropriate modalias value for a particular device tree node.
 * It does this by stripping the manufacturer prefix (as delimited by a ',')
 * from the first entry in the compatible list property.
1070
 *
1071
 * This routine returns 0 on success, <0 on failure.
1072
1073
1074
 */
int of_modalias_node(struct device_node *node, char *modalias, int len)
{
1075
1076
	const char *compatible, *p;
	int cplen;
1077
1078

	compatible = of_get_property(node, "compatible", &cplen);
1079
	if (!compatible || strlen(compatible) > cplen)
1080
1081
		return -ENODEV;
	p = strchr(compatible, ',');
1082
	strlcpy(modalias, p ? p + 1 : compatible, len);
1083
1084
1085
1086
	return 0;
}
EXPORT_SYMBOL_GPL(of_modalias_node);

1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
/**
 * of_find_node_by_phandle - Find a node given a phandle
 * @handle:	phandle of the node to find
 *
 * Returns a node pointer with refcount incremented, use
 * of_node_put() on it when done.
 */
struct device_node *of_find_node_by_phandle(phandle handle)
{
	struct device_node *np;
1097
	unsigned long flags;
1098

1099
1100
1101
	if (!handle)
		return NULL;

1102
	raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely's avatar
Grant Likely committed
1103
	for_each_of_allnodes(np)
1104
1105
1106
		if (np->phandle == handle)
			break;
	of_node_get(np);
1107
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1108
1109
1110
1111
	return np;
}
EXPORT_SYMBOL(of_find_node_by_phandle);

1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
/**
 * of_property_count_elems_of_size - Count the number of elements in a property
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @elem_size:	size of the individual element
 *
 * Search for a property in a device node and count the number of elements of
 * size elem_size in it. Returns number of elements on sucess, -EINVAL if the
 * property does not exist or its length does not match a multiple of elem_size
 * and -ENODATA if the property does not have a value.
 */
int of_property_count_elems_of_size(const struct device_node *np,
				const char *propname, int elem_size)
{
	struct property *prop = of_find_property(np, propname, NULL);

	if (!prop)
		return -EINVAL;
	if (!prop->value)
		return -ENODATA;

	if (prop->length % elem_size != 0) {
		pr_err("size of %s in node %s is not a multiple of %d\n",
		       propname, np->full_name, elem_size);
		return -EINVAL;
	}

	return prop->length / elem_size;
}
EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);

1144
1145
1146
1147
1148
/**
 * of_find_property_value_of_size
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
1149
1150
1151
 * @min:	minimum allowed length of property value
 * @max:	maximum allowed length of property value (0 means unlimited)
 * @len:	if !=NULL, actual length is written to here
1152
1153
1154
1155
 *
 * Search for a property in a device node and valid the requested size.
 * Returns the property value on success, -EINVAL if the property does not
 *  exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
1156
 * property data is too small or too large.
1157
1158
1159
 *
 */
static void *of_find_property_value_of_size(const struct device_node *np,
1160
			const char *propname, u32 min, u32 max, size_t *len)
1161
1162
1163
1164
1165
1166
1167
{
	struct property *prop = of_find_property(np, propname, NULL);

	if (!prop)
		return ERR_PTR(-EINVAL);
	if (!prop->value)
		return ERR_PTR(-ENODATA);
1168
1169
1170
	if (prop->length < min)
		return ERR_PTR(-EOVERFLOW);
	if (max && prop->length > max)
1171
1172
		return ERR_PTR(-EOVERFLOW);

1173
1174
1175
	if (len)
		*len = prop->length;

1176
1177
1178
	return prop->value;
}

1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
/**
 * of_property_read_u32_index - Find and read a u32 from a multi-value 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 u32 in the list of values
 * @out_value:	pointer to return value, modified only if no error.
 *
 * Search for a property in a device node and read nth 32-bit value 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_value is modified only if a valid u32 value can be decoded.
 */
int of_property_read_u32_index(const struct device_node *np,
				       const char *propname,
				       u32 index, u32 *out_value)
{
1198
	const u32 *val = of_find_property_value_of_size(np, propname,
1199
1200
1201
					((index + 1) * sizeof(*out_value)),
					0,
					NULL);
1202

1203
1204
	if (IS_ERR(val))
		return PTR_ERR(val);
1205

1206
	*out_value = be32_to_cpup(((__be32 *)val) + index);
1207
1208
1209
1210
	return 0;
}
EXPORT_SYMBOL_GPL(of_property_read_u32_index);

1211
/**
1212
1213
 * of_property_read_variable_u8_array - Find and read an array of u8 from a
 * property, with bounds on the minimum and maximum array size.
1214
1215
1216
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
Lad, Prabhakar's avatar
Lad, Prabhakar committed
1217
 * @out_values:	pointer to return value, modified only if return value is 0.
1218
1219
1220
1221
 * @sz_min:	minimum number of array elements to read
 * @sz_max:	maximum number of array elements to read, if zero there is no
 *		upper limit on the number of elements in the dts entry but only
 *		sz_min will be read.
1222
1223
 *
 * Search for a property in a device node and read 8-bit value(s) from
1224
1225
1226
 * it. Returns number of elements read on success, -EINVAL if the property
 * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
 * if the property data is smaller than sz_min or longer than sz_max.
1227
1228
1229
1230
 *
 * dts entry of array should be like:
 *	property = /bits/ 8 <0x50 0x60 0x70>;
 *
Lad, Prabhakar's avatar
Lad, Prabhakar committed
1231
 * The out_values is modified only if a valid u8 value can be decoded.
1232
 */
1233
1234
1235
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)
1236
{
1237
	size_t sz, count;
1238
	const u8 *val = of_find_property_value_of_size(np, propname,
1239
1240
1241
						(sz_min * sizeof(*out_values)),
						(sz_max * sizeof(*out_values)),
						&sz);
1242

1243
1244
	if (IS_ERR(val))
		return PTR_ERR(val);
1245

1246
1247
1248
1249
1250
1251
1252
	if (!sz_max)
		sz = sz_min;
	else
		sz /= sizeof(*out_values);

	count = sz;
	while (count--)
1253
		*out_values++ = *val++;
1254
1255

	return sz;
1256
}
1257
EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array);
1258
1259

/**
1260
1261
 * of_property_read_variable_u16_array - Find and read an array of u16 from a
 * property, with bounds on the minimum and maximum array size.
1262
1263
1264
 *
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
Lad, Prabhakar's avatar
Lad, Prabhakar committed
1265
 * @out_values:	pointer to return value, modified only if return value is 0.