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>
S
Stephen Rothwell 已提交
29
#include <linux/spinlock.h>
30
#include <linux/slab.h>
31
#include <linux/string.h>
J
Jeremy Kerr 已提交
32
#include <linux/proc_fs.h>
S
Stephen Rothwell 已提交
33

34
#include "of_private.h"
35

36
LIST_HEAD(aliases_lookup);
37

G
Grant Likely 已提交
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

G
Grant Likely 已提交
55
/* use when traversing tree through the child, sibling,
S
Stephen Rothwell 已提交
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

G
Grant Likely 已提交
217
	/* Symlink in /proc as required by userspace ABI */
G
Grant Likely 已提交
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)
S
Stephen Rothwell 已提交
224 225 226
{
	struct property *pp;

227 228 229
	if (!np)
		return NULL;

230
	for (pp = np->properties; pp; pp = pp->next) {
S
Stephen Rothwell 已提交
231
		if (of_prop_cmp(pp->name, name) == 0) {
232
			if (lenp)
S
Stephen Rothwell 已提交
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);
S
Stephen Rothwell 已提交
251 252 253 254 255

	return pp;
}
EXPORT_SYMBOL(of_find_property);

G
Grant Likely 已提交
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);
G
Grant Likely 已提交
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);
S
Stephen Rothwell 已提交
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;
}

G
Grant Likely 已提交
527
/**
528
 * of_machine_is_compatible - Test root of device tree for a given compatible value
G
Grant Likely 已提交
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
G
Grant Likely 已提交
532 533
 * compatible property.
 */
534
int of_machine_is_compatible(const char *compat)
G
Grant Likely 已提交
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);
G
Grant Likely 已提交
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);

S
Stephen Rothwell 已提交
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;
S
Stephen Rothwell 已提交
631 632 633 634

	if (!node)
		return NULL;

635
	raw_spin_lock_irqsave(&devtree_lock, flags);
S
Stephen Rothwell 已提交
636
	np = of_node_get(node->parent);
637
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
S
Stephen Rothwell 已提交
638 639 640
	return np;
}
EXPORT_SYMBOL(of_get_parent);
S
Stephen Rothwell 已提交
641

642 643 644 645
/**
 *	of_get_next_parent - Iterate to a node's parent
 *	@node:	Node to get parent of
 *
G
Geert Uytterhoeven 已提交
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))

S
Stephen Rothwell 已提交
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.
S
Stephen Rothwell 已提交
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;
S
Stephen Rothwell 已提交
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);
S
Stephen Rothwell 已提交
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)
G
Grant Likely 已提交
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)
G
Grant Likely 已提交
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);
G
Grant Likely 已提交
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);
G
Grant Likely 已提交
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);
G
Grant Likely 已提交
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);
G
Grant Likely 已提交
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

/**
G
Geert Uytterhoeven 已提交
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);
G
Grant Likely 已提交
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);

J
Jeremy Kerr 已提交
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;
J
Jeremy Kerr 已提交
1098

1099 1100 1101
	if (!handle)
		return NULL;

1102
	raw_spin_lock_irqsave(&devtree_lock, flags);
G
Grant Likely 已提交
1103
	for_each_of_allnodes(np)
J
Jeremy Kerr 已提交
1104 1105 1106
		if (np->phandle == handle)
			break;
	of_node_get(np);
1107
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
J
Jeremy Kerr 已提交
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.
L
Lad, Prabhakar 已提交
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>;
 *
L
Lad, Prabhakar 已提交
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.
L
Lad, Prabhakar 已提交
1265
 * @out_values:	pointer to return value, modified only if return value is 0.
1266 1267 1268 1269
 * @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.
1270 1271
 *
 * Search for a property in a device node and read 16-bit value(s) from
1272 1273 1274
 * 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.
1275 1276 1277 1278
 *
 * dts entry of array should be like:
 *	property = /bits/ 16 <0x5000 0x6000 0x7000>;
 *
L
Lad, Prabhakar 已提交
1279
 * The out_values is modified only if a valid u16 value can be decoded.
1280
 */
1281 1282 1283
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)
1284
{
1285
	size_t sz, count;
1286
	const __be16 *val = of_find_property_value_of_size(np, propname,
1287 1288 1289
						(sz_min * sizeof(*out_values)),
						(sz_max * sizeof(*out_values)),
						&sz);
1290

1291 1292
	if (IS_ERR(val))
		return PTR_ERR(val);
1293

1294 1295 1296 1297 1298 1299 1300
	if (!sz_max)
		sz = sz_min;
	else
		sz /= sizeof(*out_values);

	count = sz;
	while (count--)
1301
		*out_values++ = be16_to_cpup(val++);
1302 1303

	return sz;
1304
}
1305
EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array);
1306

1307
/**
1308 1309
 * of_property_read_variable_u32_array - Find and read an array of 32 bit
 * integers from a property, with bounds on the minimum and maximum array size.
1310
 *
1311 1312
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
L
Lad, Prabhakar 已提交
1313
 * @out_values:	pointer to return value, modified only if return value is 0.
1314 1315 1316 1317
 * @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.
1318
 *
1319
 * Search for a property in a device node and read 32-bit value(s) from
1320 1321 1322
 * 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.
1323
 *
L
Lad, Prabhakar 已提交
1324
 * The out_values is modified only if a valid u32 value can be decoded.
1325
 */
1326
int of_property_read_variable_u32_array(const struct device_node *np,
1327
			       const char *propname, u32 *out_values,
1328
			       size_t sz_min, size_t sz_max)
1329
{
1330
	size_t sz, count;
1331
	const __be32 *val = of_find_property_value_of_size(np, propname,
1332 1333 1334
						(sz_min * sizeof(*out_values)),
						(sz_max * sizeof(*out_values)),
						&sz);
1335

1336 1337
	if (IS_ERR(val))
		return PTR_ERR(val);
1338

1339 1340 1341 1342 1343 1344 1345
	if (!sz_max)
		sz = sz_min;
	else
		sz /= sizeof(*out_values);

	count = sz;
	while (count--)
1346
		*out_values++ = be32_to_cpup(val++);
1347 1348

	return sz;
1349
}
1350
EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array);
1351

1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
/**
 * of_property_read_u64 - Find and read a 64 bit integer from a property
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @out_value:	pointer to return value, modified only if return value is 0.
 *
 * Search for a property in a device node and read a 64-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 u64 value can be decoded.
 */
int of_property_read_u64(const struct device_node *np, const char *propname,
			 u64 *out_value)
{
1368
	const __be32 *val = of_find_property_value_of_size(np, propname,
1369 1370 1371
						sizeof(*out_value),
						0,
						NULL);
1372

1373 1374 1375 1376
	if (IS_ERR(val))
		return PTR_ERR(val);

	*out_value = of_read_number(val, 2);
1377 1378 1379 1380
	return 0;
}
EXPORT_SYMBOL_GPL(of_property_read_u64);

1381
/**
1382 1383
 * of_property_read_variable_u64_array - Find and read an array of 64 bit
 * integers from a property, with bounds on the minimum and maximum array size.
1384 1385 1386 1387
 *
 * @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.
1388 1389 1390 1391
 * @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.
1392 1393
 *
 * Search for a property in a device node and read 64-bit value(s) from
1394 1395 1396
 * 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.
1397 1398 1399
 *
 * The out_values is modified only if a valid u64 value can be decoded.
 */
1400
int of_property_read_variable_u64_array(const struct device_node *np,
1401
			       const char *propname, u64 *out_values,
1402
			       size_t sz_min, size_t sz_max)
1403
{
1404
	size_t sz, count;
1405
	const __be32 *val = of_find_property_value_of_size(np, propname,
1406 1407 1408
						(sz_min * sizeof(*out_values)),
						(sz_max * sizeof(*out_values)),
						&sz);
1409 1410 1411 1412

	if (IS_ERR(val))
		return PTR_ERR(val);

1413 1414 1415 1416 1417 1418 1419
	if (!sz_max)
		sz = sz_min;
	else
		sz /= sizeof(*out_values);

	count = sz;
	while (count--) {
1420 1421 1422
		*out_values++ = of_read_number(val, 2);
		val += 2;
	}
1423 1424

	return sz;
1425
}
1426
EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array);
1427

1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
/**
 * of_property_read_string - Find and read a string from a property
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
 * @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). 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.
 */
1443
int of_property_read_string(const struct device_node *np, const char *propname,
1444
				const char **out_string)
1445
{
1446
	const struct property *prop = of_find_property(np, propname, NULL);
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
	if (!prop)
		return -EINVAL;
	if (!prop->value)
		return -ENODATA;
	if (strnlen(prop->value, prop->length) >= prop->length)
		return -EILSEQ;
	*out_string = prop->value;
	return 0;
}
EXPORT_SYMBOL_GPL(of_property_read_string);

1458 1459 1460 1461 1462 1463 1464 1465 1466
/**
 * of_property_match_string() - Find string in a list and return index
 * @np: pointer to node containing string list property
 * @propname: string list property name
 * @string: pointer to string to search for in string list
 *
 * This function searches a string list property and returns the index
 * of a specific string value.
 */
1467
int of_property_match_string(const struct device_node *np, const char *propname,
1468 1469
			     const char *string)
{
1470
	const struct property *prop = of_find_property(np, propname, NULL);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
	size_t l;
	int i;
	const char *p, *end;

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

	p = prop->value;
	end = p + prop->length;

	for (i = 0; p < end; i++, p += l) {
1484
		l = strnlen(p, end - p) + 1;
1485 1486 1487 1488 1489 1490 1491 1492 1493
		if (p + l > end)
			return -EILSEQ;
		pr_debug("comparing %s with %s\n", string, p);
		if (strcmp(string, p) == 0)
			return i; /* Found it; return index */
	}
	return -ENODATA;
}
EXPORT_SYMBOL_GPL(of_property_match_string);
1494 1495

/**
1496
 * of_property_read_string_helper() - Utility helper for parsing string properties
1497 1498
 * @np:		device node from which the property value is to be read.
 * @propname:	name of the property to be searched.
1499 1500 1501
 * @out_strs:	output array of string pointers.
 * @sz:		number of array elements to read.
 * @skip:	Number of strings to skip over at beginning of list.
1502
 *
1503 1504
 * Don't call this function directly. It is a utility helper for the
 * of_property_read_string*() family of functions.
1505
 */
1506 1507 1508
int of_property_read_string_helper(const struct device_node *np,
				   const char *propname, const char **out_strs,
				   size_t sz, int skip)
1509
{
1510
	const struct property *prop = of_find_property(np, propname, NULL);
1511 1512
	int l = 0, i = 0;
	const char *p, *end;
1513 1514 1515 1516 1517 1518

	if (!prop)
		return -EINVAL;
	if (!prop->value)
		return -ENODATA;
	p = prop->value;
1519
	end = p + prop->length;
1520

1521 1522 1523 1524 1525 1526 1527 1528 1529
	for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
		l = strnlen(p, end - p) + 1;
		if (p + l > end)
			return -EILSEQ;
		if (out_strs && i >= skip)
			*out_strs++ = p;
	}
	i -= skip;
	return i <= 0 ? -ENODATA : i;
1530
}
1531
EXPORT_SYMBOL_GPL(of_property_read_string_helper);
1532

1533 1534 1535 1536
void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
{
	int i;
	printk("%s %s", msg, of_node_full_name(args->np));
1537 1538 1539 1540 1541 1542
	for (i = 0; i < args->args_count; i++) {
		const char delim = i ? ',' : ':';

		pr_cont("%c%08x", delim, args->args[i]);
	}
	pr_cont("\n");
1543 1544
}

1545 1546 1547 1548 1549
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)
1550
{
1551 1552 1553 1554
	const __be32 *list;
	int size;

	memset(it, 0, sizeof(*it));
1555 1556

	list = of_get_property(np, list_name, &size);
1557
	if (!list)
1558
		return -ENOENT;
1559

1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
	it->cells_name = cells_name;
	it->cell_count = cell_count;
	it->parent = np;
	it->list_end = list + size / sizeof(*list);
	it->phandle_end = list;
	it->cur = list;

	return 0;
}

1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
int of_phandle_iterator_next(struct of_phandle_iterator *it)
{
	uint32_t count = 0;

	if (it->node) {
		of_node_put(it->node);
		it->node = NULL;
	}

	if (!it->cur || it->phandle_end >= it->list_end)
		return -ENOENT;

	it->cur = it->phandle_end;

	/* If phandle is 0, then it is an empty entry with no arguments. */
	it->phandle = be32_to_cpup(it->cur++);

	if (it->phandle) {
1588

1589
		/*
1590 1591
		 * Find the provider node and parse the #*-cells property to
		 * determine the argument length.
1592
		 */
1593
		it->node = of_find_node_by_phandle(it->phandle);
1594

1595 1596 1597 1598 1599
		if (it->cells_name) {
			if (!it->node) {
				pr_err("%s: could not find phandle\n",
				       it->parent->full_name);
				goto err;
1600
			}
1601

1602 1603 1604 1605 1606 1607
			if (of_property_read_u32(it->node, it->cells_name,
						 &count)) {
				pr_err("%s: could not get %s for %s\n",
				       it->parent->full_name,
				       it->cells_name,
				       it->node->full_name);
1608
				goto err;
1609
			}
1610 1611
		} else {
			count = it->cell_count;
1612 1613
		}

1614
		/*
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
		 * Make sure that the arguments actually fit in the remaining
		 * property data length
		 */
		if (it->cur + count > it->list_end) {
			pr_err("%s: arguments longer than property\n",
			       it->parent->full_name);
			goto err;
		}
	}

	it->phandle_end = it->cur + count;
	it->cur_count = count;

	return 0;

err:
	if (it->node) {
		of_node_put(it->node);
		it->node = NULL;
	}

	return -EINVAL;
}

1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
int of_phandle_iterator_args(struct of_phandle_iterator *it,
			     uint32_t *args,
			     int size)
{
	int i, count;

	count = it->cur_count;

	if (WARN_ON(size < count))
		count = size;

	for (i = 0; i < count; i++)
		args[i] = be32_to_cpup(it->cur++);

	return count;
}

1656 1657
static int __of_parse_phandle_with_args(const struct device_node *np,
					const char *list_name,
1658 1659
					const char *cells_name,
					int cell_count, int index,
1660
					struct of_phandle_args *out_args)
1661
{
1662 1663
	struct of_phandle_iterator it;
	int rc, cur_index = 0;
1664

1665
	/* Loop over the phandles until all the requested entry is found */
1666
	of_for_each_phandle(&it, rc, np, list_name, cells_name, cell_count) {
1667
		/*
1668
		 * All of the error cases bail out of the loop, so at
1669 1670 1671 1672
		 * this point, the parsing is successful. If the requested
		 * index matches, then fill the out_args structure and return,
		 * or return -ENOENT for an empty entry.
		 */
1673
		rc = -ENOENT;
1674
		if (cur_index == index) {
1675
			if (!it.phandle)
1676
				goto err;
1677 1678

			if (out_args) {
1679 1680 1681 1682 1683
				int c;

				c = of_phandle_iterator_args(&it,
							     out_args->args,
							     MAX_PHANDLE_ARGS);
1684
				out_args->np = it.node;
1685
				out_args->args_count = c;
1686
			} else {
1687
				of_node_put(it.node);
1688
			}
1689 1690

			/* Found it! return success */
1691
			return 0;
1692 1693 1694 1695 1696
		}

		cur_index++;
	}

1697 1698 1699 1700 1701
	/*
	 * Unlock node before returning result; will be one of:
	 * -ENOENT : index is for empty phandle
	 * -EINVAL : parsing error on data
	 */
1702

1703
 err:
1704
	of_node_put(it.node);
1705
	return rc;
1706
}
1707

S
Stephen Warren 已提交
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
/**
 * of_parse_phandle - Resolve a phandle property to a device_node pointer
 * @np: Pointer to device node holding phandle property
 * @phandle_name: Name of property holding a phandle value
 * @index: For properties holding a table of phandles, this is the index into
 *         the table
 *
 * Returns the device_node pointer with refcount incremented.  Use
 * of_node_put() on it when done.
 */
struct device_node *of_parse_phandle(const struct device_node *np,
				     const char *phandle_name, int index)
{
1721 1722 1723 1724
	struct of_phandle_args args;

	if (index < 0)
		return NULL;
S
Stephen Warren 已提交
1725

1726 1727
	if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
					 index, &args))
S
Stephen Warren 已提交
1728 1729
		return NULL;

1730
	return args.np;
S
Stephen Warren 已提交
1731 1732 1733
}
EXPORT_SYMBOL(of_parse_phandle);

1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
/**
 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
 * @np:		pointer to a device tree node containing a list
 * @list_name:	property name that contains a list
 * @cells_name:	property name that specifies phandles' arguments count
 * @index:	index of a phandle to parse out
 * @out_args:	optional pointer to output arguments structure (will be filled)
 *
 * This function is useful to parse lists of phandles and their arguments.
 * Returns 0 on success and fills out_args, on error returns appropriate
 * errno value.
 *
1746
 * Caller is responsible to call of_node_put() on the returned out_args->np
1747 1748 1749 1750 1751
 * pointer.
 *
 * Example:
 *
 * phandle1: node1 {
G
Geert Uytterhoeven 已提交
1752
 *	#list-cells = <2>;
1753 1754 1755
 * }
 *
 * phandle2: node2 {
G
Geert Uytterhoeven 已提交
1756
 *	#list-cells = <1>;
1757 1758 1759
 * }
 *
 * node3 {
G
Geert Uytterhoeven 已提交
1760
 *	list = <&phandle1 1 2 &phandle2 3>;
1761 1762 1763 1764 1765
 * }
 *
 * To get a device_node of the `node2' node you may call this:
 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
 */
1766 1767 1768 1769 1770 1771
int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
				const char *cells_name, int index,
				struct of_phandle_args *out_args)
{
	if (index < 0)
		return -EINVAL;
1772 1773
	return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
					    index, out_args);
1774
}
1775
EXPORT_SYMBOL(of_parse_phandle_with_args);
1776

1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
/**
 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
 * @np:		pointer to a device tree node containing a list
 * @list_name:	property name that contains a list
 * @cell_count: number of argument cells following the phandle
 * @index:	index of a phandle to parse out
 * @out_args:	optional pointer to output arguments structure (will be filled)
 *
 * This function is useful to parse lists of phandles and their arguments.
 * Returns 0 on success and fills out_args, on error returns appropriate
 * errno value.
 *
1789
 * Caller is responsible to call of_node_put() on the returned out_args->np
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
 * pointer.
 *
 * Example:
 *
 * phandle1: node1 {
 * }
 *
 * phandle2: node2 {
 * }
 *
 * node3 {
G
Geert Uytterhoeven 已提交
1801
 *	list = <&phandle1 0 2 &phandle2 2 3>;
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817
 * }
 *
 * To get a device_node of the `node2' node you may call this:
 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
 */
int of_parse_phandle_with_fixed_args(const struct device_node *np,
				const char *list_name, int cell_count,
				int index, struct of_phandle_args *out_args)
{
	if (index < 0)
		return -EINVAL;
	return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
					   index, out_args);
}
EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);

1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
/**
 * of_count_phandle_with_args() - Find the number of phandles references in a property
 * @np:		pointer to a device tree node containing a list
 * @list_name:	property name that contains a list
 * @cells_name:	property name that specifies phandles' arguments count
 *
 * Returns the number of phandle + argument tuples within a property. It
 * is a typical pattern to encode a list of phandle and variable
 * arguments into a single property. The number of arguments is encoded
 * by a property in the phandle-target node. For example, a gpios
 * property would contain a list of GPIO specifies consisting of a
 * phandle and 1 or more arguments. The number of arguments are
 * determined by the #gpio-cells property in the node pointed to by the
 * phandle.
 */
int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
				const char *cells_name)
{
1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849
	struct of_phandle_iterator it;
	int rc, cur_index = 0;

	rc = of_phandle_iterator_init(&it, np, list_name, cells_name, 0);
	if (rc)
		return rc;

	while ((rc = of_phandle_iterator_next(&it)) == 0)
		cur_index += 1;

	if (rc != -ENOENT)
		return rc;

	return cur_index;
1850 1851 1852
}
EXPORT_SYMBOL(of_count_phandle_with_args);

1853 1854 1855
/**
 * __of_add_property - Add a property to a node without lock operations
 */
1856
int __of_add_property(struct device_node *np, struct property *prop)
1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
{
	struct property **next;

	prop->next = NULL;
	next = &np->properties;
	while (*next) {
		if (strcmp(prop->name, (*next)->name) == 0)
			/* duplicate ! don't insert it */
			return -EEXIST;

		next = &(*next)->next;
	}
	*next = prop;

	return 0;
}

1874
/**
1875
 * of_add_property - Add a property to a node
1876
 */
1877
int of_add_property(struct device_node *np, struct property *prop)
1878 1879
{
	unsigned long flags;
1880 1881
	int rc;

1882
	mutex_lock(&of_mutex);
1883

1884
	raw_spin_lock_irqsave(&devtree_lock, flags);
1885
	rc = __of_add_property(np, prop);
1886
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1887

1888
	if (!rc)
1889
		__of_add_property_sysfs(np, prop);
1890

1891 1892
	mutex_unlock(&of_mutex);

1893 1894 1895
	if (!rc)
		of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL);

1896
	return rc;
1897 1898
}

1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917
int __of_remove_property(struct device_node *np, struct property *prop)
{
	struct property **next;

	for (next = &np->properties; *next; next = &(*next)->next) {
		if (*next == prop)
			break;
	}
	if (*next == NULL)
		return -ENODEV;

	/* found the node */
	*next = prop->next;
	prop->next = np->deadprops;
	np->deadprops = prop;

	return 0;
}

1918 1919 1920 1921 1922 1923
void __of_sysfs_remove_bin_file(struct device_node *np, struct property *prop)
{
	sysfs_remove_bin_file(&np->kobj, &prop->attr);
	kfree(prop->attr.attr.name);
}

1924 1925
void __of_remove_property_sysfs(struct device_node *np, struct property *prop)
{
1926 1927 1928
	if (!IS_ENABLED(CONFIG_SYSFS))
		return;

1929 1930
	/* at early boot, bail here and defer setup to of_init() */
	if (of_kset && of_node_is_attached(np))
1931
		__of_sysfs_remove_bin_file(np, prop);
1932 1933
}

1934
/**
1935
 * of_remove_property - Remove a property from a node.
1936 1937 1938 1939 1940 1941
 *
 * Note that we don't actually remove it, since we have given out
 * who-knows-how-many pointers to the data using get-property.
 * Instead we just move the property to the "dead properties"
 * list, so it won't be found any more.
 */
1942
int of_remove_property(struct device_node *np, struct property *prop)
1943 1944
{
	unsigned long flags;
1945 1946
	int rc;

1947 1948 1949
	if (!prop)
		return -ENODEV;

1950
	mutex_lock(&of_mutex);
1951

1952
	raw_spin_lock_irqsave(&devtree_lock, flags);
1953
	rc = __of_remove_property(np, prop);
1954
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1955

1956 1957
	if (!rc)
		__of_remove_property_sysfs(np, prop);
1958

1959
	mutex_unlock(&of_mutex);
1960

1961 1962
	if (!rc)
		of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL);
1963

1964
	return rc;
1965 1966
}

1967 1968
int __of_update_property(struct device_node *np, struct property *newprop,
		struct property **oldpropp)
1969
{
1970
	struct property **next, *oldprop;
1971

1972 1973 1974 1975 1976
	for (next = &np->properties; *next; next = &(*next)->next) {
		if (of_prop_cmp((*next)->name, newprop->name) == 0)
			break;
	}
	*oldpropp = oldprop = *next;
1977

1978
	if (oldprop) {
1979
		/* replace the node */
1980 1981 1982 1983 1984 1985 1986 1987
		newprop->next = oldprop->next;
		*next = newprop;
		oldprop->next = np->deadprops;
		np->deadprops = oldprop;
	} else {
		/* new node */
		newprop->next = NULL;
		*next = newprop;
1988
	}
1989

1990 1991 1992
	return 0;
}

1993 1994 1995
void __of_update_property_sysfs(struct device_node *np, struct property *newprop,
		struct property *oldprop)
{
1996 1997 1998
	if (!IS_ENABLED(CONFIG_SYSFS))
		return;

1999 2000
	/* At early boot, bail out and defer setup to of_init() */
	if (!of_kset)
2001
		return;
2002

2003
	if (oldprop)
2004
		__of_sysfs_remove_bin_file(np, oldprop);
2005
	__of_add_property_sysfs(np, newprop);
2006
}
2007 2008

/*
2009
 * of_update_property - Update a property in a node, if the property does
2010
 * not exist, add it.
2011
 *
2012 2013 2014 2015
 * Note that we don't actually remove it, since we have given out
 * who-knows-how-many pointers to the data using get-property.
 * Instead we just move the property to the "dead properties" list,
 * and add the new property to the property list
2016
 */
2017
int of_update_property(struct device_node *np, struct property *newprop)
2018
{
2019
	struct property *oldprop;
2020
	unsigned long flags;
2021 2022
	int rc;

2023 2024
	if (!newprop->name)
		return -EINVAL;
2025

2026
	mutex_lock(&of_mutex);
2027

2028
	raw_spin_lock_irqsave(&devtree_lock, flags);
2029
	rc = __of_update_property(np, newprop, &oldprop);
2030
	raw_spin_unlock_irqrestore(&devtree_lock, flags);
2031

2032 2033
	if (!rc)
		__of_update_property_sysfs(np, newprop, oldprop);
2034

2035
	mutex_unlock(&of_mutex);
2036

2037 2038
	if (!rc)
		of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop);
2039

2040
	return rc;
2041 2042
}

2043 2044 2045 2046 2047 2048 2049 2050 2051
static void of_alias_add(struct alias_prop *ap, struct device_node *np,
			 int id, const char *stem, int stem_len)
{
	ap->np = np;
	ap->id = id;
	strncpy(ap->stem, stem, stem_len);
	ap->stem[stem_len] = 0;
	list_add_tail(&ap->link, &aliases_lookup);
	pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
2052
		 ap->alias, ap->stem, ap->id, of_node_full_name(np));
2053 2054 2055
}

/**
2056
 * of_alias_scan - Scan all properties of the 'aliases' node
2057
 *
2058 2059 2060
 * The function scans all the properties of the 'aliases' node and populates
 * the global lookup table with the properties.  It returns the
 * number of alias properties found, or an error code in case of failure.
2061 2062
 *
 * @dt_alloc:	An allocator that provides a virtual address to memory
2063
 *		for storing the resulting tree
2064 2065 2066 2067 2068
 */
void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
{
	struct property *pp;

2069
	of_aliases = of_find_node_by_path("/aliases");
2070 2071 2072
	of_chosen = of_find_node_by_path("/chosen");
	if (of_chosen == NULL)
		of_chosen = of_find_node_by_path("/chosen@0");
2073 2074

	if (of_chosen) {
2075
		/* linux,stdout-path and /aliases/stdout are for legacy compatibility */
2076 2077 2078
		const char *name = of_get_property(of_chosen, "stdout-path", NULL);
		if (!name)
			name = of_get_property(of_chosen, "linux,stdout-path", NULL);
2079 2080
		if (IS_ENABLED(CONFIG_PPC) && !name)
			name = of_get_property(of_aliases, "stdout", NULL);
2081
		if (name)
2082
			of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
2083 2084
	}

2085 2086 2087
	if (!of_aliases)
		return;

2088
	for_each_property_of_node(of_aliases, pp) {
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
		const char *start = pp->name;
		const char *end = start + strlen(start);
		struct device_node *np;
		struct alias_prop *ap;
		int id, len;

		/* Skip those we do not want to proceed */
		if (!strcmp(pp->name, "name") ||
		    !strcmp(pp->name, "phandle") ||
		    !strcmp(pp->name, "linux,phandle"))
			continue;

		np = of_find_node_by_path(pp->value);
		if (!np)
			continue;

		/* walk the alias backwards to extract the id and work out
		 * the 'stem' string */
		while (isdigit(*(end-1)) && end > start)
			end--;
		len = end - start;

		if (kstrtoint(end, 10, &id) < 0)
			continue;

		/* Allocate an alias_prop with enough space for the stem */
		ap = dt_alloc(sizeof(*ap) + len + 1, 4);
		if (!ap)
			continue;
2118
		memset(ap, 0, sizeof(*ap) + len + 1);
2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
		ap->alias = start;
		of_alias_add(ap, np, id, start, len);
	}
}

/**
 * of_alias_get_id - Get alias id for the given device_node
 * @np:		Pointer to the given device_node
 * @stem:	Alias stem of the given device_node
 *
2129 2130
 * The function travels the lookup table to get the alias id for the given
 * device_node and alias stem.  It returns the alias id if found.
2131 2132 2133 2134 2135 2136
 */
int of_alias_get_id(struct device_node *np, const char *stem)
{
	struct alias_prop *app;
	int id = -ENODEV;

2137
	mutex_lock(&of_mutex);
2138 2139 2140 2141 2142 2143 2144 2145 2146
	list_for_each_entry(app, &aliases_lookup, link) {
		if (strcmp(app->stem, stem) != 0)
			continue;

		if (np == app->np) {
			id = app->id;
			break;
		}
	}
2147
	mutex_unlock(&of_mutex);
2148 2149 2150 2151

	return id;
}
EXPORT_SYMBOL_GPL(of_alias_get_id);
2152

2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
/**
 * of_alias_get_highest_id - Get highest alias id for the given stem
 * @stem:	Alias stem to be examined
 *
 * The function travels the lookup table to get the highest alias id for the
 * given alias stem.  It returns the alias id if found.
 */
int of_alias_get_highest_id(const char *stem)
{
	struct alias_prop *app;
	int id = -ENODEV;

	mutex_lock(&of_mutex);
	list_for_each_entry(app, &aliases_lookup, link) {
		if (strcmp(app->stem, stem) != 0)
			continue;

		if (app->id > id)
			id = app->id;
	}
	mutex_unlock(&of_mutex);

	return id;
}
EXPORT_SYMBOL_GPL(of_alias_get_highest_id);

2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218
const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
			       u32 *pu)
{
	const void *curv = cur;

	if (!prop)
		return NULL;

	if (!cur) {
		curv = prop->value;
		goto out_val;
	}

	curv += sizeof(*cur);
	if (curv >= prop->value + prop->length)
		return NULL;

out_val:
	*pu = be32_to_cpup(curv);
	return curv;
}
EXPORT_SYMBOL_GPL(of_prop_next_u32);

const char *of_prop_next_string(struct property *prop, const char *cur)
{
	const void *curv = cur;

	if (!prop)
		return NULL;

	if (!cur)
		return prop->value;

	curv += strlen(cur) + 1;
	if (curv >= prop->value + prop->length)
		return NULL;

	return curv;
}
EXPORT_SYMBOL_GPL(of_prop_next_string);
2219 2220

/**
2221 2222 2223 2224 2225 2226 2227 2228
 * of_console_check() - Test and setup console for DT setup
 * @dn - Pointer to device node
 * @name - Name to use for preferred console without index. ex. "ttyS"
 * @index - Index to use for preferred console.
 *
 * Check if the given device node matches the stdout-path property in the
 * /chosen node. If it does then register it as the preferred console and return
 * TRUE. Otherwise return FALSE.
2229
 */
2230
bool of_console_check(struct device_node *dn, char *name, int index)
2231
{
2232
	if (!dn || dn != of_stdout || console_set_on_cmdline)
2233
		return false;
2234 2235
	return !add_preferred_console(name, index,
				      kstrdup(of_stdout_options, GFP_KERNEL));
2236
}
2237
EXPORT_SYMBOL_GPL(of_console_check);
2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268

/**
 *	of_find_next_cache_node - Find a node's subsidiary cache
 *	@np:	node of type "cpu" or "cache"
 *
 *	Returns a node pointer with refcount incremented, use
 *	of_node_put() on it when done.  Caller should hold a reference
 *	to np.
 */
struct device_node *of_find_next_cache_node(const struct device_node *np)
{
	struct device_node *child;
	const phandle *handle;

	handle = of_get_property(np, "l2-cache", NULL);
	if (!handle)
		handle = of_get_property(np, "next-level-cache", NULL);

	if (handle)
		return of_find_node_by_phandle(be32_to_cpup(handle));

	/* OF on pmac has nodes instead of properties named "l2-cache"
	 * beneath CPU nodes.
	 */
	if (!strcmp(np->type, "cpu"))
		for_each_child_of_node(np, child)
			if (!strcmp(child->type, "cache"))
				return child;

	return NULL;
}
2269

2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
/**
 * of_graph_parse_endpoint() - parse common endpoint node properties
 * @node: pointer to endpoint device_node
 * @endpoint: pointer to the OF endpoint data structure
 *
 * The caller should hold a reference to @node.
 */
int of_graph_parse_endpoint(const struct device_node *node,
			    struct of_endpoint *endpoint)
{
	struct device_node *port_node = of_get_parent(node);

2282 2283 2284
	WARN_ONCE(!port_node, "%s(): endpoint %s has no parent node\n",
		  __func__, node->full_name);

2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300
	memset(endpoint, 0, sizeof(*endpoint));

	endpoint->local_node = node;
	/*
	 * It doesn't matter whether the two calls below succeed.
	 * If they don't then the default value 0 is used.
	 */
	of_property_read_u32(port_node, "reg", &endpoint->port);
	of_property_read_u32(node, "reg", &endpoint->id);

	of_node_put(port_node);

	return 0;
}
EXPORT_SYMBOL(of_graph_parse_endpoint);

2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
/**
 * of_graph_get_port_by_id() - get the port matching a given id
 * @parent: pointer to the parent device node
 * @id: id of the port
 *
 * Return: A 'port' node pointer with refcount incremented. The caller
 * has to use of_node_put() on it when done.
 */
struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
{
	struct device_node *node, *port;

	node = of_get_child_by_name(parent, "ports");
	if (node)
		parent = node;

	for_each_child_of_node(parent, port) {
		u32 port_id = 0;

		if (of_node_cmp(port->name, "port") != 0)
			continue;
		of_property_read_u32(port, "reg", &port_id);
		if (id == port_id)
			break;
	}

	of_node_put(node);

	return port;
}
EXPORT_SYMBOL(of_graph_get_port_by_id);

2333 2334 2335 2336 2337 2338
/**
 * of_graph_get_next_endpoint() - get next endpoint node
 * @parent: pointer to the parent device node
 * @prev: previous endpoint node, or NULL to get first
 *
 * Return: An 'endpoint' node pointer with refcount incremented. Refcount
2339
 * of the passed @prev node is decremented.
2340 2341 2342 2343 2344
 */
struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
					struct device_node *prev)
{
	struct device_node *endpoint;
2345
	struct device_node *port;
2346 2347 2348 2349

	if (!parent)
		return NULL;

2350 2351 2352 2353 2354
	/*
	 * Start by locating the port node. If no previous endpoint is specified
	 * search for the first port node, otherwise get the previous endpoint
	 * parent port node.
	 */
2355 2356
	if (!prev) {
		struct device_node *node;
2357

2358 2359 2360 2361 2362 2363 2364
		node = of_get_child_by_name(parent, "ports");
		if (node)
			parent = node;

		port = of_get_child_by_name(parent, "port");
		of_node_put(node);

2365
		if (!port) {
2366 2367
			pr_err("graph: no port node found in %s\n",
			       parent->full_name);
2368 2369 2370 2371 2372 2373 2374
			return NULL;
		}
	} else {
		port = of_get_parent(prev);
		if (WARN_ONCE(!port, "%s(): endpoint %s has no parent node\n",
			      __func__, prev->full_name))
			return NULL;
2375 2376
	}

2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387
	while (1) {
		/*
		 * Now that we have a port node, get the next endpoint by
		 * getting the next child. If the previous endpoint is NULL this
		 * will return the first child.
		 */
		endpoint = of_get_next_child(port, prev);
		if (endpoint) {
			of_node_put(port);
			return endpoint;
		}
2388

2389 2390
		/* No more endpoints under this port, try the next one. */
		prev = NULL;
2391

2392 2393 2394 2395 2396 2397
		do {
			port = of_get_next_child(parent, port);
			if (!port)
				return NULL;
		} while (of_node_cmp(port->name, "port"));
	}
2398 2399 2400
}
EXPORT_SYMBOL(of_graph_get_next_endpoint);

2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414
/**
 * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers
 * @parent: pointer to the parent device node
 * @port_reg: identifier (value of reg property) of the parent port node
 * @reg: identifier (value of reg property) of the endpoint node
 *
 * Return: An 'endpoint' node pointer which is identified by reg and at the same
 * is the child of a port node identified by port_reg. reg and port_reg are
 * ignored when they are -1.
 */
struct device_node *of_graph_get_endpoint_by_regs(
	const struct device_node *parent, int port_reg, int reg)
{
	struct of_endpoint endpoint;
2415
	struct device_node *node = NULL;
2416

2417
	for_each_endpoint_of_node(parent, node) {
2418 2419 2420 2421 2422 2423 2424 2425
		of_graph_parse_endpoint(node, &endpoint);
		if (((port_reg == -1) || (endpoint.port == port_reg)) &&
			((reg == -1) || (endpoint.id == reg)))
			return node;
	}

	return NULL;
}
2426
EXPORT_SYMBOL(of_graph_get_endpoint_by_regs);
2427

2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
/**
 * of_graph_get_remote_port_parent() - get remote port's parent node
 * @node: pointer to a local endpoint device_node
 *
 * Return: Remote device node associated with remote endpoint node linked
 *	   to @node. Use of_node_put() on it when done.
 */
struct device_node *of_graph_get_remote_port_parent(
			       const struct device_node *node)
{
	struct device_node *np;
	unsigned int depth;

	/* Get remote endpoint node. */
	np = of_parse_phandle(node, "remote-endpoint", 0);

	/* Walk 3 levels up only if there is 'ports' node. */
	for (depth = 3; depth && np; depth--) {
		np = of_get_next_parent(np);
		if (depth == 2 && of_node_cmp(np->name, "ports"))
			break;
	}
	return np;
}
EXPORT_SYMBOL(of_graph_get_remote_port_parent);

/**
 * of_graph_get_remote_port() - get remote port node
 * @node: pointer to a local endpoint device_node
 *
 * Return: Remote port node associated with remote endpoint node linked
 *	   to @node. Use of_node_put() on it when done.
 */
struct device_node *of_graph_get_remote_port(const struct device_node *node)
{
	struct device_node *np;

	/* Get remote endpoint node. */
	np = of_parse_phandle(node, "remote-endpoint", 0);
	if (!np)
		return NULL;
	return of_get_next_parent(np);
}
EXPORT_SYMBOL(of_graph_get_remote_port);