1/*
   2 * Procedures for creating, accessing and interpreting the device tree.
   3 *
   4 * Paul Mackerras	August 1996.
   5 * Copyright (C) 1996-2005 Paul Mackerras.
   6 *
   7 *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
   8 *    {engebret|bergner}@us.ibm.com
   9 *
  10 *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
  11 *
  12 *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
  13 *  Grant Likely.
  14 *
  15 *      This program is free software; you can redistribute it and/or
  16 *      modify it under the terms of the GNU General Public License
  17 *      as published by the Free Software Foundation; either version
  18 *      2 of the License, or (at your option) any later version.
  19 */
 
 
 
 
  20#include <linux/ctype.h>
  21#include <linux/cpu.h>
  22#include <linux/module.h>
  23#include <linux/of.h>
 
  24#include <linux/of_graph.h>
  25#include <linux/spinlock.h>
  26#include <linux/slab.h>
  27#include <linux/string.h>
  28#include <linux/proc_fs.h>
  29
  30#include "of_private.h"
  31
  32LIST_HEAD(aliases_lookup);
  33
  34struct device_node *of_allnodes;
  35EXPORT_SYMBOL(of_allnodes);
  36struct device_node *of_chosen;
 
  37struct device_node *of_aliases;
  38static struct device_node *of_stdout;
 
  39
  40static struct kset *of_kset;
  41
  42/*
  43 * Used to protect the of_aliases; but also overloaded to hold off addition of
  44 * nodes to sysfs
 
 
  45 */
  46DEFINE_MUTEX(of_aliases_mutex);
  47
  48/* use when traversing tree through the allnext, child, sibling,
  49 * or parent members of struct device_node.
  50 */
  51DEFINE_RAW_SPINLOCK(devtree_lock);
  52
  53int of_n_addr_cells(struct device_node *np)
  54{
  55	const __be32 *ip;
 
  56
  57	do {
  58		if (np->parent)
  59			np = np->parent;
  60		ip = of_get_property(np, "#address-cells", NULL);
  61		if (ip)
  62			return be32_to_cpup(ip);
  63	} while (np->parent);
  64	/* No #address-cells property for the root node */
  65	return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
  66}
  67EXPORT_SYMBOL(of_n_addr_cells);
  68
  69int of_n_size_cells(struct device_node *np)
  70{
  71	const __be32 *ip;
  72
  73	do {
  74		if (np->parent)
  75			np = np->parent;
  76		ip = of_get_property(np, "#size-cells", NULL);
  77		if (ip)
  78			return be32_to_cpup(ip);
  79	} while (np->parent);
  80	/* No #size-cells property for the root node */
  81	return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
  82}
  83EXPORT_SYMBOL(of_n_size_cells);
  84
  85#ifdef CONFIG_NUMA
  86int __weak of_node_to_nid(struct device_node *np)
  87{
  88	return numa_node_id();
  89}
  90#endif
  91
  92#if defined(CONFIG_OF_DYNAMIC)
  93/**
  94 *	of_node_get - Increment refcount of a node
  95 *	@node:	Node to inc refcount, NULL is supported to
  96 *		simplify writing of callers
  97 *
  98 *	Returns node.
  99 */
 100struct device_node *of_node_get(struct device_node *node)
 101{
 102	if (node)
 103		kobject_get(&node->kobj);
 104	return node;
 105}
 106EXPORT_SYMBOL(of_node_get);
 107
 108static inline struct device_node *kobj_to_device_node(struct kobject *kobj)
 109{
 110	return container_of(kobj, struct device_node, kobj);
 
 
 111}
 112
 113/**
 114 *	of_node_release - release a dynamically allocated node
 115 *	@kref:  kref element of the node to be released
 116 *
 117 *	In of_node_put() this function is passed to kref_put()
 118 *	as the destructor.
 119 */
 120static void of_node_release(struct kobject *kobj)
 121{
 122	struct device_node *node = kobj_to_device_node(kobj);
 123	struct property *prop = node->properties;
 124
 125	/* We should never be releasing nodes that haven't been detached. */
 126	if (!of_node_check_flag(node, OF_DETACHED)) {
 127		pr_err("ERROR: Bad of_node_put() on %s\n", node->full_name);
 128		dump_stack();
 129		return;
 130	}
 131
 132	if (!of_node_check_flag(node, OF_DYNAMIC))
 133		return;
 
 134
 135	while (prop) {
 136		struct property *next = prop->next;
 137		kfree(prop->name);
 138		kfree(prop->value);
 139		kfree(prop);
 140		prop = next;
 141
 142		if (!prop) {
 143			prop = node->deadprops;
 144			node->deadprops = NULL;
 145		}
 146	}
 147	kfree(node->full_name);
 148	kfree(node->data);
 149	kfree(node);
 150}
 151
 152/**
 153 *	of_node_put - Decrement refcount of a node
 154 *	@node:	Node to dec refcount, NULL is supported to
 155 *		simplify writing of callers
 156 *
 157 */
 158void of_node_put(struct device_node *node)
 159{
 160	if (node)
 161		kobject_put(&node->kobj);
 162}
 163EXPORT_SYMBOL(of_node_put);
 164#else
 165static void of_node_release(struct kobject *kobj)
 166{
 167	/* Without CONFIG_OF_DYNAMIC, no nodes gets freed */
 168}
 169#endif /* CONFIG_OF_DYNAMIC */
 170
 171struct kobj_type of_node_ktype = {
 172	.release = of_node_release,
 173};
 174
 175static ssize_t of_node_property_read(struct file *filp, struct kobject *kobj,
 176				struct bin_attribute *bin_attr, char *buf,
 177				loff_t offset, size_t count)
 178{
 179	struct property *pp = container_of(bin_attr, struct property, attr);
 180	return memory_read_from_buffer(buf, count, &offset, pp->value, pp->length);
 181}
 
 182
 183static const char *safe_name(struct kobject *kobj, const char *orig_name)
 184{
 185	const char *name = orig_name;
 186	struct kernfs_node *kn;
 187	int i = 0;
 188
 189	/* don't be a hero. After 16 tries give up */
 190	while (i < 16 && (kn = sysfs_get_dirent(kobj->sd, name))) {
 191		sysfs_put(kn);
 192		if (name != orig_name)
 193			kfree(name);
 194		name = kasprintf(GFP_KERNEL, "%s#%i", orig_name, ++i);
 195	}
 196
 197	if (name != orig_name)
 198		pr_warn("device-tree: Duplicate name in %s, renamed to \"%s\"\n",
 199			kobject_name(kobj), name);
 200	return name;
 201}
 202
 203static int __of_add_property_sysfs(struct device_node *np, struct property *pp)
 204{
 205	int rc;
 
 206
 207	/* Important: Don't leak passwords */
 208	bool secure = strncmp(pp->name, "security-", 9) == 0;
 209
 210	sysfs_bin_attr_init(&pp->attr);
 211	pp->attr.attr.name = safe_name(&np->kobj, pp->name);
 212	pp->attr.attr.mode = secure ? S_IRUSR : S_IRUGO;
 213	pp->attr.size = secure ? 0 : pp->length;
 214	pp->attr.read = of_node_property_read;
 215
 216	rc = sysfs_create_bin_file(&np->kobj, &pp->attr);
 217	WARN(rc, "error adding attribute %s to node %s\n", pp->name, np->full_name);
 218	return rc;
 219}
 
 220
 221static int __of_node_add(struct device_node *np)
 
 222{
 223	const char *name;
 224	struct property *pp;
 225	int rc;
 226
 227	np->kobj.kset = of_kset;
 228	if (!np->parent) {
 229		/* Nodes without parents are new top level trees */
 230		rc = kobject_add(&np->kobj, NULL, safe_name(&of_kset->kobj, "base"));
 231	} else {
 232		name = safe_name(&np->parent->kobj, kbasename(np->full_name));
 233		if (!name || !name[0])
 234			return -EINVAL;
 235
 236		rc = kobject_add(&np->kobj, &np->parent->kobj, "%s", name);
 237	}
 238	if (rc)
 239		return rc;
 240
 241	for_each_property_of_node(np, pp)
 242		__of_add_property_sysfs(np, pp);
 243
 244	return 0;
 245}
 
 246
 247int of_node_add(struct device_node *np)
 248{
 249	int rc = 0;
 250
 251	BUG_ON(!of_node_is_initialized(np));
 252
 253	/*
 254	 * Grab the mutex here so that in a race condition between of_init() and
 255	 * of_node_add(), node addition will still be consistent.
 256	 */
 257	mutex_lock(&of_aliases_mutex);
 258	if (of_kset)
 259		rc = __of_node_add(np);
 260	else
 261		/* This scenario may be perfectly valid, but report it anyway */
 262		pr_info("of_node_add(%s) before of_init()\n", np->full_name);
 263	mutex_unlock(&of_aliases_mutex);
 264	return rc;
 265}
 266
 267#if defined(CONFIG_OF_DYNAMIC)
 268static void of_node_remove(struct device_node *np)
 
 
 269{
 270	struct property *pp;
 
 271
 272	BUG_ON(!of_node_is_initialized(np));
 
 273
 274	/* only remove properties if on sysfs */
 275	if (of_node_is_attached(np)) {
 276		for_each_property_of_node(np, pp)
 277			sysfs_remove_bin_file(&np->kobj, &pp->attr);
 278		kobject_del(&np->kobj);
 279	}
 280
 281	/* finally remove the kobj_init ref */
 282	of_node_put(np);
 
 283}
 284#endif
 285
 286static int __init of_init(void)
 287{
 288	struct device_node *np;
 289
 
 
 290	/* Create the kset, and register existing nodes */
 291	mutex_lock(&of_aliases_mutex);
 292	of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
 293	if (!of_kset) {
 294		mutex_unlock(&of_aliases_mutex);
 295		return -ENOMEM;
 
 
 
 
 
 
 296	}
 297	for_each_of_allnodes(np)
 298		__of_node_add(np);
 299	mutex_unlock(&of_aliases_mutex);
 300
 301	/* Symlink in /proc as required by userspace ABI */
 302	if (of_allnodes)
 303		proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
 304
 305	return 0;
 306}
 307core_initcall(of_init);
 308
 309static struct property *__of_find_property(const struct device_node *np,
 310					   const char *name, int *lenp)
 311{
 312	struct property *pp;
 313
 314	if (!np)
 315		return NULL;
 316
 317	for (pp = np->properties; pp; pp = pp->next) {
 318		if (of_prop_cmp(pp->name, name) == 0) {
 319			if (lenp)
 320				*lenp = pp->length;
 321			break;
 322		}
 323	}
 324
 325	return pp;
 326}
 327
 328struct property *of_find_property(const struct device_node *np,
 329				  const char *name,
 330				  int *lenp)
 331{
 332	struct property *pp;
 333	unsigned long flags;
 334
 335	raw_spin_lock_irqsave(&devtree_lock, flags);
 336	pp = __of_find_property(np, name, lenp);
 337	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 338
 339	return pp;
 340}
 341EXPORT_SYMBOL(of_find_property);
 342
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 343/**
 344 * of_find_all_nodes - Get next node in global list
 345 * @prev:	Previous node or NULL to start iteration
 346 *		of_node_put() will be called on it
 347 *
 348 * Returns a node pointer with refcount incremented, use
 349 * of_node_put() on it when done.
 350 */
 351struct device_node *of_find_all_nodes(struct device_node *prev)
 352{
 353	struct device_node *np;
 354	unsigned long flags;
 355
 356	raw_spin_lock_irqsave(&devtree_lock, flags);
 357	np = prev ? prev->allnext : of_allnodes;
 358	for (; np != NULL; np = np->allnext)
 359		if (of_node_get(np))
 360			break;
 361	of_node_put(prev);
 362	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 363	return np;
 364}
 365EXPORT_SYMBOL(of_find_all_nodes);
 366
 367/*
 368 * Find a property with a given name for a given node
 369 * and return the value.
 370 */
 371static const void *__of_get_property(const struct device_node *np,
 372				     const char *name, int *lenp)
 373{
 374	struct property *pp = __of_find_property(np, name, lenp);
 375
 376	return pp ? pp->value : NULL;
 377}
 378
 379/*
 380 * Find a property with a given name for a given node
 381 * and return the value.
 382 */
 383const void *of_get_property(const struct device_node *np, const char *name,
 384			    int *lenp)
 385{
 386	struct property *pp = of_find_property(np, name, lenp);
 387
 388	return pp ? pp->value : NULL;
 389}
 390EXPORT_SYMBOL(of_get_property);
 391
 392/*
 393 * arch_match_cpu_phys_id - Match the given logical CPU and physical id
 394 *
 395 * @cpu: logical cpu index of a core/thread
 396 * @phys_id: physical identifier of a core/thread
 397 *
 398 * CPU logical to physical index mapping is architecture specific.
 399 * However this __weak function provides a default match of physical
 400 * id to logical cpu index. phys_id provided here is usually values read
 401 * from the device tree which must match the hardware internal registers.
 402 *
 403 * Returns true if the physical identifier and the logical cpu index
 404 * correspond to the same core/thread, false otherwise.
 405 */
 406bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
 407{
 408	return (u32)phys_id == cpu;
 409}
 410
 411/**
 412 * Checks if the given "prop_name" property holds the physical id of the
 413 * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
 414 * NULL, local thread number within the core is returned in it.
 415 */
 416static bool __of_find_n_match_cpu_property(struct device_node *cpun,
 417			const char *prop_name, int cpu, unsigned int *thread)
 418{
 419	const __be32 *cell;
 420	int ac, prop_len, tid;
 421	u64 hwid;
 422
 423	ac = of_n_addr_cells(cpun);
 424	cell = of_get_property(cpun, prop_name, &prop_len);
 425	if (!cell || !ac)
 426		return false;
 427	prop_len /= sizeof(*cell) * ac;
 428	for (tid = 0; tid < prop_len; tid++) {
 429		hwid = of_read_number(cell, ac);
 430		if (arch_match_cpu_phys_id(cpu, hwid)) {
 431			if (thread)
 432				*thread = tid;
 433			return true;
 434		}
 435		cell += ac;
 436	}
 437	return false;
 438}
 439
 440/*
 441 * arch_find_n_match_cpu_physical_id - See if the given device node is
 442 * for the cpu corresponding to logical cpu 'cpu'.  Return true if so,
 443 * else false.  If 'thread' is non-NULL, the local thread number within the
 444 * core is returned in it.
 445 */
 446bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun,
 447					      int cpu, unsigned int *thread)
 448{
 449	/* Check for non-standard "ibm,ppc-interrupt-server#s" property
 450	 * for thread ids on PowerPC. If it doesn't exist fallback to
 451	 * standard "reg" property.
 452	 */
 453	if (IS_ENABLED(CONFIG_PPC) &&
 454	    __of_find_n_match_cpu_property(cpun,
 455					   "ibm,ppc-interrupt-server#s",
 456					   cpu, thread))
 457		return true;
 458
 459	if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread))
 460		return true;
 461
 462	return false;
 463}
 464
 465/**
 466 * of_get_cpu_node - Get device node associated with the given logical CPU
 467 *
 468 * @cpu: CPU number(logical index) for which device node is required
 469 * @thread: if not NULL, local thread number within the physical core is
 470 *          returned
 471 *
 472 * The main purpose of this function is to retrieve the device node for the
 473 * given logical CPU index. It should be used to initialize the of_node in
 474 * cpu device. Once of_node in cpu device is populated, all the further
 475 * references can use that instead.
 476 *
 477 * CPU logical to physical index mapping is architecture specific and is built
 478 * before booting secondary cores. This function uses arch_match_cpu_phys_id
 479 * which can be overridden by architecture specific implementation.
 480 *
 481 * Returns a node pointer for the logical cpu if found, else NULL.
 482 */
 483struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
 484{
 485	struct device_node *cpun;
 486
 487	for_each_node_by_type(cpun, "cpu") {
 488		if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
 489			return cpun;
 490	}
 491	return NULL;
 492}
 493EXPORT_SYMBOL(of_get_cpu_node);
 494
 495/**
 496 * __of_device_is_compatible() - Check if the node matches given constraints
 497 * @device: pointer to node
 498 * @compat: required compatible string, NULL or "" for any match
 499 * @type: required device_type value, NULL or "" for any match
 500 * @name: required node name, NULL or "" for any match
 501 *
 502 * Checks if the given @compat, @type and @name strings match the
 503 * properties of the given @device. A constraints can be skipped by
 504 * passing NULL or an empty string as the constraint.
 505 *
 506 * Returns 0 for no match, and a positive integer on match. The return
 507 * value is a relative score with larger values indicating better
 508 * matches. The score is weighted for the most specific compatible value
 509 * to get the highest score. Matching type is next, followed by matching
 510 * name. Practically speaking, this results in the following priority
 511 * order for matches:
 512 *
 513 * 1. specific compatible && type && name
 514 * 2. specific compatible && type
 515 * 3. specific compatible && name
 516 * 4. specific compatible
 517 * 5. general compatible && type && name
 518 * 6. general compatible && type
 519 * 7. general compatible && name
 520 * 8. general compatible
 521 * 9. type && name
 522 * 10. type
 523 * 11. name
 524 */
 525static int __of_device_is_compatible(const struct device_node *device,
 526				     const char *compat, const char *type, const char *name)
 527{
 528	struct property *prop;
 529	const char *cp;
 530	int index = 0, score = 0;
 531
 532	/* Compatible match has highest priority */
 533	if (compat && compat[0]) {
 534		prop = __of_find_property(device, "compatible", NULL);
 535		for (cp = of_prop_next_string(prop, NULL); cp;
 536		     cp = of_prop_next_string(prop, cp), index++) {
 537			if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
 538				score = INT_MAX/2 - (index << 2);
 539				break;
 540			}
 541		}
 542		if (!score)
 543			return 0;
 544	}
 545
 546	/* Matching type is better than matching name */
 547	if (type && type[0]) {
 548		if (!device->type || of_node_cmp(type, device->type))
 549			return 0;
 550		score += 2;
 551	}
 552
 553	/* Matching name is a bit better than not */
 554	if (name && name[0]) {
 555		if (!device->name || of_node_cmp(name, device->name))
 556			return 0;
 557		score++;
 558	}
 559
 560	return score;
 561}
 562
 563/** Checks if the given "compat" string matches one of the strings in
 564 * the device's "compatible" property
 565 */
 566int of_device_is_compatible(const struct device_node *device,
 567		const char *compat)
 568{
 569	unsigned long flags;
 570	int res;
 571
 572	raw_spin_lock_irqsave(&devtree_lock, flags);
 573	res = __of_device_is_compatible(device, compat, NULL, NULL);
 574	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 575	return res;
 576}
 577EXPORT_SYMBOL(of_device_is_compatible);
 578
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 579/**
 580 * of_machine_is_compatible - Test root of device tree for a given compatible value
 581 * @compat: compatible string to look for in root node's compatible property.
 582 *
 583 * Returns true if the root node has the given value in its
 584 * compatible property.
 585 */
 586int of_machine_is_compatible(const char *compat)
 587{
 588	struct device_node *root;
 589	int rc = 0;
 590
 591	root = of_find_node_by_path("/");
 592	if (root) {
 593		rc = of_device_is_compatible(root, compat);
 594		of_node_put(root);
 595	}
 596	return rc;
 
 597}
 598EXPORT_SYMBOL(of_machine_is_compatible);
 599
 600/**
 601 *  __of_device_is_available - check if a device is available for use
 602 *
 603 *  @device: Node to check for availability, with locks already held
 604 *
 605 *  Returns 1 if the status property is absent or set to "okay" or "ok",
 606 *  0 otherwise
 607 */
 608static int __of_device_is_available(const struct device_node *device)
 609{
 610	const char *status;
 611	int statlen;
 612
 613	if (!device)
 614		return 0;
 615
 616	status = __of_get_property(device, "status", &statlen);
 617	if (status == NULL)
 618		return 1;
 619
 620	if (statlen > 0) {
 621		if (!strcmp(status, "okay") || !strcmp(status, "ok"))
 622			return 1;
 
 
 
 
 
 
 
 
 
 
 623	}
 624
 625	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 626}
 627
 628/**
 629 *  of_device_is_available - check if a device is available for use
 630 *
 631 *  @device: Node to check for availability
 632 *
 633 *  Returns 1 if the status property is absent or set to "okay" or "ok",
 634 *  0 otherwise
 635 */
 636int of_device_is_available(const struct device_node *device)
 637{
 638	unsigned long flags;
 639	int res;
 640
 641	raw_spin_lock_irqsave(&devtree_lock, flags);
 642	res = __of_device_is_available(device);
 643	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 644	return res;
 645
 646}
 647EXPORT_SYMBOL(of_device_is_available);
 648
 649/**
 650 *	of_get_parent - Get a node's parent if any
 651 *	@node:	Node to get parent
 652 *
 653 *	Returns a node pointer with refcount incremented, use
 654 *	of_node_put() on it when done.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 655 */
 656struct device_node *of_get_parent(const struct device_node *node)
 657{
 658	struct device_node *np;
 659	unsigned long flags;
 660
 661	if (!node)
 662		return NULL;
 663
 664	raw_spin_lock_irqsave(&devtree_lock, flags);
 665	np = of_node_get(node->parent);
 666	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 667	return np;
 668}
 669EXPORT_SYMBOL(of_get_parent);
 670
 671/**
 672 *	of_get_next_parent - Iterate to a node's parent
 673 *	@node:	Node to get parent of
 674 *
 675 * 	This is like of_get_parent() except that it drops the
 676 * 	refcount on the passed node, making it suitable for iterating
 677 * 	through a node's parents.
 678 *
 679 *	Returns a node pointer with refcount incremented, use
 680 *	of_node_put() on it when done.
 681 */
 682struct device_node *of_get_next_parent(struct device_node *node)
 683{
 684	struct device_node *parent;
 685	unsigned long flags;
 686
 687	if (!node)
 688		return NULL;
 689
 690	raw_spin_lock_irqsave(&devtree_lock, flags);
 691	parent = of_node_get(node->parent);
 692	of_node_put(node);
 693	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 694	return parent;
 695}
 696EXPORT_SYMBOL(of_get_next_parent);
 697
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 698/**
 699 *	of_get_next_child - Iterate a node childs
 700 *	@node:	parent node
 701 *	@prev:	previous child of the parent node, or NULL to get first
 702 *
 703 *	Returns a node pointer with refcount incremented, use
 704 *	of_node_put() on it when done.
 
 705 */
 706struct device_node *of_get_next_child(const struct device_node *node,
 707	struct device_node *prev)
 708{
 709	struct device_node *next;
 710	unsigned long flags;
 711
 712	raw_spin_lock_irqsave(&devtree_lock, flags);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 713	next = prev ? prev->sibling : node->child;
 714	for (; next; next = next->sibling)
 
 
 715		if (of_node_get(next))
 716			break;
 
 717	of_node_put(prev);
 718	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 719	return next;
 720}
 721EXPORT_SYMBOL(of_get_next_child);
 722
 723/**
 724 *	of_get_next_available_child - Find the next available child node
 725 *	@node:	parent node
 726 *	@prev:	previous child of the parent node, or NULL to get first
 727 *
 728 *      This function is like of_get_next_child(), except that it
 729 *      automatically skips any disabled nodes (i.e. status = "disabled").
 730 */
 731struct device_node *of_get_next_available_child(const struct device_node *node,
 732	struct device_node *prev)
 733{
 734	struct device_node *next;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 735	unsigned long flags;
 
 
 
 
 736
 737	raw_spin_lock_irqsave(&devtree_lock, flags);
 738	next = prev ? prev->sibling : node->child;
 
 
 
 
 
 739	for (; next; next = next->sibling) {
 740		if (!__of_device_is_available(next))
 
 
 
 741			continue;
 742		if (of_node_get(next))
 743			break;
 744	}
 745	of_node_put(prev);
 746	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 747	return next;
 748}
 749EXPORT_SYMBOL(of_get_next_available_child);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 750
 751/**
 752 *	of_get_child_by_name - Find the child node by name for a given parent
 753 *	@node:	parent node
 754 *	@name:	child name to look for.
 755 *
 756 *      This function looks for child node for given matching name
 757 *
 758 *	Returns a node pointer if found, with refcount incremented, use
 759 *	of_node_put() on it when done.
 760 *	Returns NULL if node is not found.
 761 */
 762struct device_node *of_get_child_by_name(const struct device_node *node,
 763				const char *name)
 764{
 765	struct device_node *child;
 766
 767	for_each_child_of_node(node, child)
 768		if (child->name && (of_node_cmp(child->name, name) == 0))
 769			break;
 770	return child;
 771}
 772EXPORT_SYMBOL(of_get_child_by_name);
 773
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 774/**
 775 *	of_find_node_by_path - Find a node matching a full OF path
 776 *	@path:	The full path to match
 
 
 
 
 
 
 
 
 
 
 
 777 *
 778 *	Returns a node pointer with refcount incremented, use
 779 *	of_node_put() on it when done.
 780 */
 781struct device_node *of_find_node_by_path(const char *path)
 782{
 783	struct device_node *np = of_allnodes;
 
 784	unsigned long flags;
 
 785
 786	raw_spin_lock_irqsave(&devtree_lock, flags);
 787	for (; np; np = np->allnext) {
 788		if (np->full_name && (of_node_cmp(np->full_name, path) == 0)
 789		    && of_node_get(np))
 790			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 791	}
 
 
 
 
 
 
 792	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 793	return np;
 794}
 795EXPORT_SYMBOL(of_find_node_by_path);
 796
 797/**
 798 *	of_find_node_by_name - Find a node by its "name" property
 799 *	@from:	The node to start searching from or NULL, the node
 800 *		you pass will not be searched, only the next one
 801 *		will; typically, you pass what the previous call
 802 *		returned. of_node_put() will be called on it
 803 *	@name:	The name string to match against
 804 *
 805 *	Returns a node pointer with refcount incremented, use
 806 *	of_node_put() on it when done.
 807 */
 808struct device_node *of_find_node_by_name(struct device_node *from,
 809	const char *name)
 810{
 811	struct device_node *np;
 812	unsigned long flags;
 813
 814	raw_spin_lock_irqsave(&devtree_lock, flags);
 815	np = from ? from->allnext : of_allnodes;
 816	for (; np; np = np->allnext)
 817		if (np->name && (of_node_cmp(np->name, name) == 0)
 818		    && of_node_get(np))
 819			break;
 820	of_node_put(from);
 821	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 822	return np;
 823}
 824EXPORT_SYMBOL(of_find_node_by_name);
 825
 826/**
 827 *	of_find_node_by_type - Find a node by its "device_type" property
 828 *	@from:	The node to start searching from, or NULL to start searching
 829 *		the entire device tree. The node you pass will not be
 830 *		searched, only the next one will; typically, you pass
 831 *		what the previous call returned. of_node_put() will be
 832 *		called on from for you.
 833 *	@type:	The type string to match against
 834 *
 835 *	Returns a node pointer with refcount incremented, use
 836 *	of_node_put() on it when done.
 837 */
 838struct device_node *of_find_node_by_type(struct device_node *from,
 839	const char *type)
 840{
 841	struct device_node *np;
 842	unsigned long flags;
 843
 844	raw_spin_lock_irqsave(&devtree_lock, flags);
 845	np = from ? from->allnext : of_allnodes;
 846	for (; np; np = np->allnext)
 847		if (np->type && (of_node_cmp(np->type, type) == 0)
 848		    && of_node_get(np))
 849			break;
 850	of_node_put(from);
 851	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 852	return np;
 853}
 854EXPORT_SYMBOL(of_find_node_by_type);
 855
 856/**
 857 *	of_find_compatible_node - Find a node based on type and one of the
 858 *                                tokens in its "compatible" property
 859 *	@from:		The node to start searching from or NULL, the node
 860 *			you pass will not be searched, only the next one
 861 *			will; typically, you pass what the previous call
 862 *			returned. of_node_put() will be called on it
 863 *	@type:		The type string to match "device_type" or NULL to ignore
 864 *	@compatible:	The string to match to one of the tokens in the device
 865 *			"compatible" list.
 866 *
 867 *	Returns a node pointer with refcount incremented, use
 868 *	of_node_put() on it when done.
 869 */
 870struct device_node *of_find_compatible_node(struct device_node *from,
 871	const char *type, const char *compatible)
 872{
 873	struct device_node *np;
 874	unsigned long flags;
 875
 876	raw_spin_lock_irqsave(&devtree_lock, flags);
 877	np = from ? from->allnext : of_allnodes;
 878	for (; np; np = np->allnext) {
 879		if (__of_device_is_compatible(np, compatible, type, NULL) &&
 880		    of_node_get(np))
 881			break;
 882	}
 883	of_node_put(from);
 884	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 885	return np;
 886}
 887EXPORT_SYMBOL(of_find_compatible_node);
 888
 889/**
 890 *	of_find_node_with_property - Find a node which has a property with
 891 *                                   the given name.
 892 *	@from:		The node to start searching from or NULL, the node
 893 *			you pass will not be searched, only the next one
 894 *			will; typically, you pass what the previous call
 895 *			returned. of_node_put() will be called on it
 896 *	@prop_name:	The name of the property to look for.
 897 *
 898 *	Returns a node pointer with refcount incremented, use
 899 *	of_node_put() on it when done.
 900 */
 901struct device_node *of_find_node_with_property(struct device_node *from,
 902	const char *prop_name)
 903{
 904	struct device_node *np;
 905	struct property *pp;
 906	unsigned long flags;
 907
 908	raw_spin_lock_irqsave(&devtree_lock, flags);
 909	np = from ? from->allnext : of_allnodes;
 910	for (; np; np = np->allnext) {
 911		for (pp = np->properties; pp; pp = pp->next) {
 912			if (of_prop_cmp(pp->name, prop_name) == 0) {
 913				of_node_get(np);
 914				goto out;
 915			}
 916		}
 917	}
 918out:
 919	of_node_put(from);
 920	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 921	return np;
 922}
 923EXPORT_SYMBOL(of_find_node_with_property);
 924
 925static
 926const struct of_device_id *__of_match_node(const struct of_device_id *matches,
 927					   const struct device_node *node)
 928{
 929	const struct of_device_id *best_match = NULL;
 930	int score, best_score = 0;
 931
 932	if (!matches)
 933		return NULL;
 934
 935	for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
 936		score = __of_device_is_compatible(node, matches->compatible,
 937						  matches->type, matches->name);
 938		if (score > best_score) {
 939			best_match = matches;
 940			best_score = score;
 941		}
 942	}
 943
 944	return best_match;
 945}
 946
 947/**
 948 * of_match_node - Tell if an device_node has a matching of_match structure
 949 *	@matches:	array of of device match structures to search in
 950 *	@node:		the of device structure to match against
 951 *
 952 *	Low level utility function used by device matching.
 953 */
 954const struct of_device_id *of_match_node(const struct of_device_id *matches,
 955					 const struct device_node *node)
 956{
 957	const struct of_device_id *match;
 958	unsigned long flags;
 959
 960	raw_spin_lock_irqsave(&devtree_lock, flags);
 961	match = __of_match_node(matches, node);
 962	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 963	return match;
 964}
 965EXPORT_SYMBOL(of_match_node);
 966
 967/**
 968 *	of_find_matching_node_and_match - Find a node based on an of_device_id
 969 *					  match table.
 970 *	@from:		The node to start searching from or NULL, the node
 971 *			you pass will not be searched, only the next one
 972 *			will; typically, you pass what the previous call
 973 *			returned. of_node_put() will be called on it
 974 *	@matches:	array of of device match structures to search in
 975 *	@match		Updated to point at the matches entry which matched
 976 *
 977 *	Returns a node pointer with refcount incremented, use
 978 *	of_node_put() on it when done.
 979 */
 980struct device_node *of_find_matching_node_and_match(struct device_node *from,
 981					const struct of_device_id *matches,
 982					const struct of_device_id **match)
 983{
 984	struct device_node *np;
 985	const struct of_device_id *m;
 986	unsigned long flags;
 987
 988	if (match)
 989		*match = NULL;
 990
 991	raw_spin_lock_irqsave(&devtree_lock, flags);
 992	np = from ? from->allnext : of_allnodes;
 993	for (; np; np = np->allnext) {
 994		m = __of_match_node(matches, np);
 995		if (m && of_node_get(np)) {
 996			if (match)
 997				*match = m;
 998			break;
 999		}
1000	}
1001	of_node_put(from);
1002	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1003	return np;
1004}
1005EXPORT_SYMBOL(of_find_matching_node_and_match);
1006
1007/**
1008 * of_modalias_node - Lookup appropriate modalias for a device node
 
1009 * @node:	pointer to a device tree node
1010 * @modalias:	Pointer to buffer that modalias value will be copied into
1011 * @len:	Length of modalias value
1012 *
1013 * Based on the value of the compatible property, this routine will attempt
1014 * to choose an appropriate modalias value for a particular device tree node.
1015 * It does this by stripping the manufacturer prefix (as delimited by a ',')
1016 * from the first entry in the compatible list property.
1017 *
1018 * This routine returns 0 on success, <0 on failure.
 
 
 
1019 */
1020int of_modalias_node(struct device_node *node, char *modalias, int len)
1021{
1022	const char *compatible, *p;
1023	int cplen;
1024
1025	compatible = of_get_property(node, "compatible", &cplen);
1026	if (!compatible || strlen(compatible) > cplen)
1027		return -ENODEV;
1028	p = strchr(compatible, ',');
1029	strlcpy(modalias, p ? p + 1 : compatible, len);
1030	return 0;
1031}
1032EXPORT_SYMBOL_GPL(of_modalias_node);
1033
1034/**
1035 * of_find_node_by_phandle - Find a node given a phandle
1036 * @handle:	phandle of the node to find
1037 *
1038 * Returns a node pointer with refcount incremented, use
1039 * of_node_put() on it when done.
1040 */
1041struct device_node *of_find_node_by_phandle(phandle handle)
1042{
1043	struct device_node *np;
1044	unsigned long flags;
 
 
 
 
 
 
1045
1046	raw_spin_lock_irqsave(&devtree_lock, flags);
1047	for (np = of_allnodes; np; np = np->allnext)
1048		if (np->phandle == handle)
1049			break;
 
 
 
 
 
 
 
 
 
 
 
1050	of_node_get(np);
1051	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1052	return np;
1053}
1054EXPORT_SYMBOL(of_find_node_by_phandle);
1055
1056/**
1057 * of_property_count_elems_of_size - Count the number of elements in a property
1058 *
1059 * @np:		device node from which the property value is to be read.
1060 * @propname:	name of the property to be searched.
1061 * @elem_size:	size of the individual element
1062 *
1063 * Search for a property in a device node and count the number of elements of
1064 * size elem_size in it. Returns number of elements on sucess, -EINVAL if the
1065 * property does not exist or its length does not match a multiple of elem_size
1066 * and -ENODATA if the property does not have a value.
1067 */
1068int of_property_count_elems_of_size(const struct device_node *np,
1069				const char *propname, int elem_size)
1070{
1071	struct property *prop = of_find_property(np, propname, NULL);
1072
1073	if (!prop)
1074		return -EINVAL;
1075	if (!prop->value)
1076		return -ENODATA;
1077
1078	if (prop->length % elem_size != 0) {
1079		pr_err("size of %s in node %s is not a multiple of %d\n",
1080		       propname, np->full_name, elem_size);
1081		return -EINVAL;
1082	}
1083
1084	return prop->length / elem_size;
1085}
1086EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
1087
1088/**
1089 * of_find_property_value_of_size
1090 *
1091 * @np:		device node from which the property value is to be read.
1092 * @propname:	name of the property to be searched.
1093 * @len:	requested length of property value
1094 *
1095 * Search for a property in a device node and valid the requested size.
1096 * Returns the property value on success, -EINVAL if the property does not
1097 *  exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
1098 * property data isn't large enough.
1099 *
1100 */
1101static void *of_find_property_value_of_size(const struct device_node *np,
1102			const char *propname, u32 len)
1103{
1104	struct property *prop = of_find_property(np, propname, NULL);
 
1105
1106	if (!prop)
1107		return ERR_PTR(-EINVAL);
1108	if (!prop->value)
1109		return ERR_PTR(-ENODATA);
1110	if (len > prop->length)
1111		return ERR_PTR(-EOVERFLOW);
1112
1113	return prop->value;
1114}
 
 
 
 
1115
1116/**
1117 * of_property_read_u32_index - Find and read a u32 from a multi-value property.
1118 *
1119 * @np:		device node from which the property value is to be read.
1120 * @propname:	name of the property to be searched.
1121 * @index:	index of the u32 in the list of values
1122 * @out_value:	pointer to return value, modified only if no error.
1123 *
1124 * Search for a property in a device node and read nth 32-bit value from
1125 * it. Returns 0 on success, -EINVAL if the property does not exist,
1126 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1127 * property data isn't large enough.
1128 *
1129 * The out_value is modified only if a valid u32 value can be decoded.
1130 */
1131int of_property_read_u32_index(const struct device_node *np,
1132				       const char *propname,
1133				       u32 index, u32 *out_value)
1134{
1135	const u32 *val = of_find_property_value_of_size(np, propname,
1136					((index + 1) * sizeof(*out_value)));
1137
1138	if (IS_ERR(val))
1139		return PTR_ERR(val);
 
 
 
 
1140
1141	*out_value = be32_to_cpup(((__be32 *)val) + index);
1142	return 0;
1143}
1144EXPORT_SYMBOL_GPL(of_property_read_u32_index);
1145
1146/**
1147 * of_property_read_u8_array - Find and read an array of u8 from a property.
1148 *
1149 * @np:		device node from which the property value is to be read.
1150 * @propname:	name of the property to be searched.
1151 * @out_values:	pointer to return value, modified only if return value is 0.
1152 * @sz:		number of array elements to read
1153 *
1154 * Search for a property in a device node and read 8-bit value(s) from
1155 * it. Returns 0 on success, -EINVAL if the property does not exist,
1156 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1157 * property data isn't large enough.
1158 *
1159 * dts entry of array should be like:
1160 *	property = /bits/ 8 <0x50 0x60 0x70>;
1161 *
1162 * The out_values is modified only if a valid u8 value can be decoded.
1163 */
1164int of_property_read_u8_array(const struct device_node *np,
1165			const char *propname, u8 *out_values, size_t sz)
1166{
1167	const u8 *val = of_find_property_value_of_size(np, propname,
1168						(sz * sizeof(*out_values)));
1169
1170	if (IS_ERR(val))
1171		return PTR_ERR(val);
1172
1173	while (sz--)
1174		*out_values++ = *val++;
1175	return 0;
1176}
1177EXPORT_SYMBOL_GPL(of_property_read_u8_array);
1178
1179/**
1180 * of_property_read_u16_array - Find and read an array of u16 from a property.
1181 *
1182 * @np:		device node from which the property value is to be read.
1183 * @propname:	name of the property to be searched.
1184 * @out_values:	pointer to return value, modified only if return value is 0.
1185 * @sz:		number of array elements to read
1186 *
1187 * Search for a property in a device node and read 16-bit value(s) from
1188 * it. Returns 0 on success, -EINVAL if the property does not exist,
1189 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1190 * property data isn't large enough.
1191 *
1192 * dts entry of array should be like:
1193 *	property = /bits/ 16 <0x5000 0x6000 0x7000>;
1194 *
1195 * The out_values is modified only if a valid u16 value can be decoded.
1196 */
1197int of_property_read_u16_array(const struct device_node *np,
1198			const char *propname, u16 *out_values, size_t sz)
1199{
1200	const __be16 *val = of_find_property_value_of_size(np, propname,
1201						(sz * sizeof(*out_values)));
1202
1203	if (IS_ERR(val))
1204		return PTR_ERR(val);
1205
1206	while (sz--)
1207		*out_values++ = be16_to_cpup(val++);
1208	return 0;
1209}
1210EXPORT_SYMBOL_GPL(of_property_read_u16_array);
1211
1212/**
1213 * of_property_read_u32_array - Find and read an array of 32 bit integers
1214 * from a property.
1215 *
1216 * @np:		device node from which the property value is to be read.
1217 * @propname:	name of the property to be searched.
1218 * @out_values:	pointer to return value, modified only if return value is 0.
1219 * @sz:		number of array elements to read
1220 *
1221 * Search for a property in a device node and read 32-bit value(s) from
1222 * it. Returns 0 on success, -EINVAL if the property does not exist,
1223 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1224 * property data isn't large enough.
1225 *
1226 * The out_values is modified only if a valid u32 value can be decoded.
1227 */
1228int of_property_read_u32_array(const struct device_node *np,
1229			       const char *propname, u32 *out_values,
1230			       size_t sz)
1231{
1232	const __be32 *val = of_find_property_value_of_size(np, propname,
1233						(sz * sizeof(*out_values)));
1234
1235	if (IS_ERR(val))
1236		return PTR_ERR(val);
 
 
 
1237
1238	while (sz--)
1239		*out_values++ = be32_to_cpup(val++);
1240	return 0;
1241}
1242EXPORT_SYMBOL_GPL(of_property_read_u32_array);
 
1243
1244/**
1245 * of_property_read_u64 - Find and read a 64 bit integer from a property
1246 * @np:		device node from which the property value is to be read.
1247 * @propname:	name of the property to be searched.
1248 * @out_value:	pointer to return value, modified only if return value is 0.
1249 *
1250 * Search for a property in a device node and read a 64-bit value from
1251 * it. Returns 0 on success, -EINVAL if the property does not exist,
1252 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1253 * property data isn't large enough.
1254 *
1255 * The out_value is modified only if a valid u64 value can be decoded.
1256 */
1257int of_property_read_u64(const struct device_node *np, const char *propname,
1258			 u64 *out_value)
1259{
1260	const __be32 *val = of_find_property_value_of_size(np, propname,
1261						sizeof(*out_value));
 
 
1262
1263	if (IS_ERR(val))
1264		return PTR_ERR(val);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1265
1266	*out_value = of_read_number(val, 2);
1267	return 0;
1268}
1269EXPORT_SYMBOL_GPL(of_property_read_u64);
1270
1271/**
1272 * of_property_read_string - Find and read a string from a property
1273 * @np:		device node from which the property value is to be read.
1274 * @propname:	name of the property to be searched.
1275 * @out_string:	pointer to null terminated return string, modified only if
1276 *		return value is 0.
1277 *
1278 * Search for a property in a device tree node and retrieve a null
1279 * terminated string value (pointer to data, not a copy). Returns 0 on
1280 * success, -EINVAL if the property does not exist, -ENODATA if property
1281 * does not have a value, and -EILSEQ if the string is not null-terminated
1282 * within the length of the property data.
1283 *
1284 * The out_string pointer is modified only if a valid string can be decoded.
1285 */
1286int of_property_read_string(struct device_node *np, const char *propname,
1287				const char **out_string)
1288{
1289	struct property *prop = of_find_property(np, propname, NULL);
1290	if (!prop)
1291		return -EINVAL;
1292	if (!prop->value)
1293		return -ENODATA;
1294	if (strnlen(prop->value, prop->length) >= prop->length)
1295		return -EILSEQ;
1296	*out_string = prop->value;
1297	return 0;
1298}
1299EXPORT_SYMBOL_GPL(of_property_read_string);
1300
1301/**
1302 * of_property_read_string_index - Find and read a string from a multiple
1303 * strings property.
1304 * @np:		device node from which the property value is to be read.
1305 * @propname:	name of the property to be searched.
1306 * @index:	index of the string in the list of strings
1307 * @out_string:	pointer to null terminated return string, modified only if
1308 *		return value is 0.
1309 *
1310 * Search for a property in a device tree node and retrieve a null
1311 * terminated string value (pointer to data, not a copy) in the list of strings
1312 * contained in that property.
1313 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
1314 * property does not have a value, and -EILSEQ if the string is not
1315 * null-terminated within the length of the property data.
1316 *
1317 * The out_string pointer is modified only if a valid string can be decoded.
1318 */
1319int of_property_read_string_index(struct device_node *np, const char *propname,
1320				  int index, const char **output)
1321{
1322	struct property *prop = of_find_property(np, propname, NULL);
1323	int i = 0;
1324	size_t l = 0, total = 0;
1325	const char *p;
1326
1327	if (!prop)
1328		return -EINVAL;
1329	if (!prop->value)
1330		return -ENODATA;
1331	if (strnlen(prop->value, prop->length) >= prop->length)
1332		return -EILSEQ;
1333
1334	p = prop->value;
1335
1336	for (i = 0; total < prop->length; total += l, p += l) {
1337		l = strlen(p) + 1;
1338		if (i++ == index) {
1339			*output = p;
1340			return 0;
1341		}
1342	}
1343	return -ENODATA;
 
1344}
1345EXPORT_SYMBOL_GPL(of_property_read_string_index);
1346
1347/**
1348 * of_property_match_string() - Find string in a list and return index
1349 * @np: pointer to node containing string list property
1350 * @propname: string list property name
1351 * @string: pointer to string to search for in string list
1352 *
1353 * This function searches a string list property and returns the index
1354 * of a specific string value.
1355 */
1356int of_property_match_string(struct device_node *np, const char *propname,
1357			     const char *string)
1358{
1359	struct property *prop = of_find_property(np, propname, NULL);
1360	size_t l;
1361	int i;
1362	const char *p, *end;
1363
1364	if (!prop)
1365		return -EINVAL;
1366	if (!prop->value)
1367		return -ENODATA;
1368
1369	p = prop->value;
1370	end = p + prop->length;
1371
1372	for (i = 0; p < end; i++, p += l) {
1373		l = strlen(p) + 1;
1374		if (p + l > end)
1375			return -EILSEQ;
1376		pr_debug("comparing %s with %s\n", string, p);
1377		if (strcmp(string, p) == 0)
1378			return i; /* Found it; return index */
1379	}
1380	return -ENODATA;
1381}
1382EXPORT_SYMBOL_GPL(of_property_match_string);
1383
1384/**
1385 * of_property_count_strings - Find and return the number of strings from a
1386 * multiple strings property.
1387 * @np:		device node from which the property value is to be read.
1388 * @propname:	name of the property to be searched.
1389 *
1390 * Search for a property in a device tree node and retrieve the number of null
1391 * terminated string contain in it. Returns the number of strings on
1392 * success, -EINVAL if the property does not exist, -ENODATA if property
1393 * does not have a value, and -EILSEQ if the string is not null-terminated
1394 * within the length of the property data.
1395 */
1396int of_property_count_strings(struct device_node *np, const char *propname)
1397{
1398	struct property *prop = of_find_property(np, propname, NULL);
1399	int i = 0;
1400	size_t l = 0, total = 0;
1401	const char *p;
1402
1403	if (!prop)
1404		return -EINVAL;
1405	if (!prop->value)
1406		return -ENODATA;
1407	if (strnlen(prop->value, prop->length) >= prop->length)
1408		return -EILSEQ;
1409
1410	p = prop->value;
1411
1412	for (i = 0; total < prop->length; total += l, p += l, i++)
1413		l = strlen(p) + 1;
1414
1415	return i;
1416}
1417EXPORT_SYMBOL_GPL(of_property_count_strings);
1418
1419void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
1420{
1421	int i;
1422	printk("%s %s", msg, of_node_full_name(args->np));
1423	for (i = 0; i < args->args_count; i++)
1424		printk(i ? ",%08x" : ":%08x", args->args[i]);
1425	printk("\n");
1426}
1427
1428static int __of_parse_phandle_with_args(const struct device_node *np,
1429					const char *list_name,
1430					const char *cells_name,
1431					int cell_count, int index,
1432					struct of_phandle_args *out_args)
1433{
1434	const __be32 *list, *list_end;
1435	int rc = 0, size, cur_index = 0;
1436	uint32_t count = 0;
1437	struct device_node *node = NULL;
1438	phandle phandle;
1439
1440	/* Retrieve the phandle list property */
1441	list = of_get_property(np, list_name, &size);
1442	if (!list)
1443		return -ENOENT;
1444	list_end = list + size / sizeof(*list);
1445
1446	/* Loop over the phandles until all the requested entry is found */
1447	while (list < list_end) {
1448		rc = -EINVAL;
1449		count = 0;
1450
1451		/*
1452		 * If phandle is 0, then it is an empty entry with no
1453		 * arguments.  Skip forward to the next entry.
1454		 */
1455		phandle = be32_to_cpup(list++);
1456		if (phandle) {
1457			/*
1458			 * Find the provider node and parse the #*-cells
1459			 * property to determine the argument length.
1460			 *
1461			 * This is not needed if the cell count is hard-coded
1462			 * (i.e. cells_name not set, but cell_count is set),
1463			 * except when we're going to return the found node
1464			 * below.
1465			 */
1466			if (cells_name || cur_index == index) {
1467				node = of_find_node_by_phandle(phandle);
1468				if (!node) {
1469					pr_err("%s: could not find phandle\n",
1470						np->full_name);
1471					goto err;
1472				}
1473			}
1474
1475			if (cells_name) {
1476				if (of_property_read_u32(node, cells_name,
1477							 &count)) {
1478					pr_err("%s: could not get %s for %s\n",
1479						np->full_name, cells_name,
1480						node->full_name);
1481					goto err;
1482				}
1483			} else {
1484				count = cell_count;
1485			}
1486
1487			/*
1488			 * Make sure that the arguments actually fit in the
1489			 * remaining property data length
1490			 */
1491			if (list + count > list_end) {
1492				pr_err("%s: arguments longer than property\n",
1493					 np->full_name);
1494				goto err;
1495			}
1496		}
1497
1498		/*
1499		 * All of the error cases above bail out of the loop, so at
1500		 * this point, the parsing is successful. If the requested
1501		 * index matches, then fill the out_args structure and return,
1502		 * or return -ENOENT for an empty entry.
1503		 */
1504		rc = -ENOENT;
1505		if (cur_index == index) {
1506			if (!phandle)
1507				goto err;
1508
1509			if (out_args) {
1510				int i;
1511				if (WARN_ON(count > MAX_PHANDLE_ARGS))
1512					count = MAX_PHANDLE_ARGS;
1513				out_args->np = node;
1514				out_args->args_count = count;
1515				for (i = 0; i < count; i++)
1516					out_args->args[i] = be32_to_cpup(list++);
1517			} else {
1518				of_node_put(node);
1519			}
1520
1521			/* Found it! return success */
1522			return 0;
1523		}
1524
1525		of_node_put(node);
1526		node = NULL;
1527		list += count;
1528		cur_index++;
1529	}
1530
1531	/*
1532	 * Unlock node before returning result; will be one of:
1533	 * -ENOENT : index is for empty phandle
1534	 * -EINVAL : parsing error on data
1535	 * [1..n]  : Number of phandle (count mode; when index = -1)
1536	 */
1537	rc = index < 0 ? cur_index : -ENOENT;
1538 err:
1539	if (node)
1540		of_node_put(node);
1541	return rc;
1542}
 
1543
1544/**
1545 * of_parse_phandle - Resolve a phandle property to a device_node pointer
1546 * @np: Pointer to device node holding phandle property
1547 * @phandle_name: Name of property holding a phandle value
1548 * @index: For properties holding a table of phandles, this is the index into
1549 *         the table
1550 *
1551 * Returns the device_node pointer with refcount incremented.  Use
1552 * of_node_put() on it when done.
1553 */
1554struct device_node *of_parse_phandle(const struct device_node *np,
1555				     const char *phandle_name, int index)
1556{
1557	struct of_phandle_args args;
1558
1559	if (index < 0)
1560		return NULL;
1561
1562	if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
1563					 index, &args))
1564		return NULL;
1565
1566	return args.np;
1567}
1568EXPORT_SYMBOL(of_parse_phandle);
1569
1570/**
1571 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
1572 * @np:		pointer to a device tree node containing a list
1573 * @list_name:	property name that contains a list
1574 * @cells_name:	property name that specifies phandles' arguments count
1575 * @index:	index of a phandle to parse out
1576 * @out_args:	optional pointer to output arguments structure (will be filled)
1577 *
1578 * This function is useful to parse lists of phandles and their arguments.
1579 * Returns 0 on success and fills out_args, on error returns appropriate
1580 * errno value.
 
 
1581 *
1582 * Caller is responsible to call of_node_put() on the returned out_args->node
1583 * pointer.
1584 *
1585 * Example:
1586 *
1587 * phandle1: node1 {
1588 * 	#list-cells = <2>;
1589 * }
1590 *
1591 * phandle2: node2 {
1592 * 	#list-cells = <1>;
1593 * }
1594 *
1595 * node3 {
1596 * 	list = <&phandle1 1 2 &phandle2 3>;
1597 * }
1598 *
1599 * To get a device_node of the `node2' node you may call this:
1600 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1601 */
1602int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
1603				const char *cells_name, int index,
1604				struct of_phandle_args *out_args)
1605{
1606	if (index < 0)
1607		return -EINVAL;
1608	return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
1609					    index, out_args);
1610}
1611EXPORT_SYMBOL(of_parse_phandle_with_args);
 
 
 
 
 
 
 
 
 
 
 
 
 
1612
1613/**
1614 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
1615 * @np:		pointer to a device tree node containing a list
1616 * @list_name:	property name that contains a list
1617 * @cell_count: number of argument cells following the phandle
1618 * @index:	index of a phandle to parse out
1619 * @out_args:	optional pointer to output arguments structure (will be filled)
1620 *
1621 * This function is useful to parse lists of phandles and their arguments.
1622 * Returns 0 on success and fills out_args, on error returns appropriate
1623 * errno value.
1624 *
1625 * Caller is responsible to call of_node_put() on the returned out_args->node
1626 * pointer.
1627 *
1628 * Example:
1629 *
1630 * phandle1: node1 {
1631 * }
1632 *
1633 * phandle2: node2 {
1634 * }
1635 *
1636 * node3 {
1637 * 	list = <&phandle1 0 2 &phandle2 2 3>;
1638 * }
1639 *
1640 * To get a device_node of the `node2' node you may call this:
1641 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
1642 */
1643int of_parse_phandle_with_fixed_args(const struct device_node *np,
1644				const char *list_name, int cell_count,
1645				int index, struct of_phandle_args *out_args)
1646{
1647	if (index < 0)
1648		return -EINVAL;
1649	return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
1650					   index, out_args);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1651}
1652EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);
1653
1654/**
1655 * of_count_phandle_with_args() - Find the number of phandles references in a property
1656 * @np:		pointer to a device tree node containing a list
1657 * @list_name:	property name that contains a list
1658 * @cells_name:	property name that specifies phandles' arguments count
1659 *
1660 * Returns the number of phandle + argument tuples within a property. It
1661 * is a typical pattern to encode a list of phandle and variable
1662 * arguments into a single property. The number of arguments is encoded
1663 * by a property in the phandle-target node. For example, a gpios
1664 * property would contain a list of GPIO specifies consisting of a
1665 * phandle and 1 or more arguments. The number of arguments are
1666 * determined by the #gpio-cells property in the node pointed to by the
1667 * phandle.
1668 */
1669int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
1670				const char *cells_name)
1671{
1672	return __of_parse_phandle_with_args(np, list_name, cells_name, 0, -1,
1673					    NULL);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1674}
1675EXPORT_SYMBOL(of_count_phandle_with_args);
1676
1677#if defined(CONFIG_OF_DYNAMIC)
1678static int of_property_notify(int action, struct device_node *np,
1679			      struct property *prop)
1680{
1681	struct of_prop_reconfig pr;
1682
1683	/* only call notifiers if the node is attached */
1684	if (!of_node_is_attached(np))
1685		return 0;
1686
1687	pr.dn = np;
1688	pr.prop = prop;
1689	return of_reconfig_notify(action, &pr);
1690}
1691#else
1692static int of_property_notify(int action, struct device_node *np,
1693			      struct property *prop)
1694{
1695	return 0;
1696}
1697#endif
1698
1699/**
1700 * __of_add_property - Add a property to a node without lock operations
 
 
1701 */
1702static int __of_add_property(struct device_node *np, struct property *prop)
1703{
 
 
1704	struct property **next;
1705
 
 
 
 
1706	prop->next = NULL;
1707	next = &np->properties;
1708	while (*next) {
1709		if (strcmp(prop->name, (*next)->name) == 0)
1710			/* duplicate ! don't insert it */
1711			return -EEXIST;
1712
 
1713		next = &(*next)->next;
1714	}
1715	*next = prop;
1716
 
 
 
 
 
 
1717	return 0;
1718}
1719
1720/**
1721 * of_add_property - Add a property to a node
 
 
1722 */
1723int of_add_property(struct device_node *np, struct property *prop)
1724{
1725	unsigned long flags;
1726	int rc;
1727
1728	rc = of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop);
1729	if (rc)
1730		return rc;
 
 
 
 
 
 
 
 
 
 
 
 
1731
1732	raw_spin_lock_irqsave(&devtree_lock, flags);
1733	rc = __of_add_property(np, prop);
 
 
 
 
 
 
 
1734	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1735	if (rc)
1736		return rc;
1737
1738	if (of_node_is_attached(np))
1739		__of_add_property_sysfs(np, prop);
1740
1741	return rc;
1742}
1743
1744/**
1745 * of_remove_property - Remove a property from a node.
 
 
1746 *
1747 * Note that we don't actually remove it, since we have given out
1748 * who-knows-how-many pointers to the data using get-property.
1749 * Instead we just move the property to the "dead properties"
1750 * list, so it won't be found any more.
1751 */
1752int of_remove_property(struct device_node *np, struct property *prop)
1753{
1754	struct property **next;
1755	unsigned long flags;
1756	int found = 0;
1757	int rc;
1758
1759	rc = of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1760	if (rc)
1761		return rc;
1762
1763	raw_spin_lock_irqsave(&devtree_lock, flags);
1764	next = &np->properties;
1765	while (*next) {
1766		if (*next == prop) {
1767			/* found the node */
1768			*next = prop->next;
1769			prop->next = np->deadprops;
1770			np->deadprops = prop;
1771			found = 1;
1772			break;
1773		}
1774		next = &(*next)->next;
1775	}
1776	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1777
1778	if (!found)
1779		return -ENODEV;
1780
1781	/* at early boot, bail hear and defer setup to of_init() */
1782	if (!of_kset)
1783		return 0;
1784
1785	sysfs_remove_bin_file(&np->kobj, &prop->attr);
 
1786
1787	return 0;
1788}
 
1789
1790/*
1791 * of_update_property - Update a property in a node, if the property does
1792 * not exist, add it.
1793 *
1794 * Note that we don't actually remove it, since we have given out
1795 * who-knows-how-many pointers to the data using get-property.
1796 * Instead we just move the property to the "dead properties" list,
1797 * and add the new property to the property list
1798 */
1799int of_update_property(struct device_node *np, struct property *newprop)
1800{
1801	struct property **next, *oldprop;
1802	unsigned long flags;
1803	int rc, found = 0;
1804
1805	rc = of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop);
1806	if (rc)
1807		return rc;
1808
1809	if (!newprop->name)
1810		return -EINVAL;
1811
1812	oldprop = of_find_property(np, newprop->name, NULL);
1813	if (!oldprop)
1814		return of_add_property(np, newprop);
1815
1816	raw_spin_lock_irqsave(&devtree_lock, flags);
1817	next = &np->properties;
1818	while (*next) {
1819		if (*next == oldprop) {
1820			/* found the node */
1821			newprop->next = oldprop->next;
1822			*next = newprop;
1823			oldprop->next = np->deadprops;
1824			np->deadprops = oldprop;
1825			found = 1;
1826			break;
1827		}
1828		next = &(*next)->next;
1829	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1830	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1831	if (!found)
1832		return -ENODEV;
1833
1834	/* At early boot, bail out and defer setup to of_init() */
1835	if (!of_kset)
1836		return found ? 0 : -ENODEV;
1837
1838	/* Update the sysfs attribute */
1839	sysfs_remove_bin_file(&np->kobj, &oldprop->attr);
1840	__of_add_property_sysfs(np, newprop);
1841
1842	return 0;
1843}
1844
1845#if defined(CONFIG_OF_DYNAMIC)
1846/*
1847 * Support for dynamic device trees.
 
1848 *
1849 * On some platforms, the device tree can be manipulated at runtime.
1850 * The routines in this section support adding, removing and changing
1851 * device tree nodes.
1852 */
1853
1854static BLOCKING_NOTIFIER_HEAD(of_reconfig_chain);
1855
1856int of_reconfig_notifier_register(struct notifier_block *nb)
1857{
1858	return blocking_notifier_chain_register(&of_reconfig_chain, nb);
1859}
1860EXPORT_SYMBOL_GPL(of_reconfig_notifier_register);
1861
1862int of_reconfig_notifier_unregister(struct notifier_block *nb)
1863{
1864	return blocking_notifier_chain_unregister(&of_reconfig_chain, nb);
1865}
1866EXPORT_SYMBOL_GPL(of_reconfig_notifier_unregister);
1867
1868int of_reconfig_notify(unsigned long action, void *p)
1869{
1870	int rc;
1871
1872	rc = blocking_notifier_call_chain(&of_reconfig_chain, action, p);
1873	return notifier_to_errno(rc);
1874}
1875
1876/**
1877 * of_attach_node - Plug a device node into the tree and global list.
1878 */
1879int of_attach_node(struct device_node *np)
1880{
1881	unsigned long flags;
1882	int rc;
1883
1884	rc = of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, np);
1885	if (rc)
1886		return rc;
1887
1888	raw_spin_lock_irqsave(&devtree_lock, flags);
1889	np->sibling = np->parent->child;
1890	np->allnext = of_allnodes;
1891	np->parent->child = np;
1892	of_allnodes = np;
1893	of_node_clear_flag(np, OF_DETACHED);
1894	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1895
1896	of_node_add(np);
1897	return 0;
1898}
1899
1900/**
1901 * of_detach_node - "Unplug" a node from the device tree.
1902 *
1903 * The caller must hold a reference to the node.  The memory associated with
1904 * the node is not freed until its refcount goes to zero.
1905 */
1906int of_detach_node(struct device_node *np)
1907{
1908	struct device_node *parent;
1909	unsigned long flags;
1910	int rc = 0;
1911
1912	rc = of_reconfig_notify(OF_RECONFIG_DETACH_NODE, np);
1913	if (rc)
1914		return rc;
1915
1916	raw_spin_lock_irqsave(&devtree_lock, flags);
1917
1918	if (of_node_check_flag(np, OF_DETACHED)) {
1919		/* someone already detached it */
1920		raw_spin_unlock_irqrestore(&devtree_lock, flags);
1921		return rc;
1922	}
1923
1924	parent = np->parent;
1925	if (!parent) {
1926		raw_spin_unlock_irqrestore(&devtree_lock, flags);
1927		return rc;
1928	}
1929
1930	if (of_allnodes == np)
1931		of_allnodes = np->allnext;
1932	else {
1933		struct device_node *prev;
1934		for (prev = of_allnodes;
1935		     prev->allnext != np;
1936		     prev = prev->allnext)
1937			;
1938		prev->allnext = np->allnext;
1939	}
1940
1941	if (parent->child == np)
1942		parent->child = np->sibling;
1943	else {
1944		struct device_node *prevsib;
1945		for (prevsib = np->parent->child;
1946		     prevsib->sibling != np;
1947		     prevsib = prevsib->sibling)
1948			;
1949		prevsib->sibling = np->sibling;
1950	}
1951
1952	of_node_set_flag(np, OF_DETACHED);
1953	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1954
1955	of_node_remove(np);
1956	return rc;
1957}
1958#endif /* defined(CONFIG_OF_DYNAMIC) */
1959
1960static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1961			 int id, const char *stem, int stem_len)
1962{
1963	ap->np = np;
1964	ap->id = id;
1965	strncpy(ap->stem, stem, stem_len);
1966	ap->stem[stem_len] = 0;
1967	list_add_tail(&ap->link, &aliases_lookup);
1968	pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
1969		 ap->alias, ap->stem, ap->id, of_node_full_name(np));
1970}
1971
1972/**
1973 * of_alias_scan - Scan all properties of 'aliases' node
1974 *
1975 * The function scans all the properties of 'aliases' node and populate
1976 * the the global lookup table with the properties.  It returns the
1977 * number of alias_prop found, or error code in error case.
1978 *
1979 * @dt_alloc:	An allocator that provides a virtual address to memory
1980 *		for the resulting tree
 
 
 
 
1981 */
1982void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1983{
1984	struct property *pp;
1985
 
1986	of_chosen = of_find_node_by_path("/chosen");
1987	if (of_chosen == NULL)
1988		of_chosen = of_find_node_by_path("/chosen@0");
1989
1990	if (of_chosen) {
1991		const char *name = of_get_property(of_chosen, "stdout-path", NULL);
1992		if (!name)
1993			name = of_get_property(of_chosen, "linux,stdout-path", NULL);
 
 
 
 
 
1994		if (name)
1995			of_stdout = of_find_node_by_path(name);
 
 
1996	}
1997
1998	of_aliases = of_find_node_by_path("/aliases");
1999	if (!of_aliases)
2000		return;
2001
2002	for_each_property_of_node(of_aliases, pp) {
2003		const char *start = pp->name;
2004		const char *end = start + strlen(start);
2005		struct device_node *np;
2006		struct alias_prop *ap;
2007		int id, len;
2008
2009		/* Skip those we do not want to proceed */
2010		if (!strcmp(pp->name, "name") ||
2011		    !strcmp(pp->name, "phandle") ||
2012		    !strcmp(pp->name, "linux,phandle"))
2013			continue;
2014
2015		np = of_find_node_by_path(pp->value);
2016		if (!np)
2017			continue;
2018
2019		/* walk the alias backwards to extract the id and work out
2020		 * the 'stem' string */
2021		while (isdigit(*(end-1)) && end > start)
2022			end--;
2023		len = end - start;
2024
2025		if (kstrtoint(end, 10, &id) < 0)
2026			continue;
2027
2028		/* Allocate an alias_prop with enough space for the stem */
2029		ap = dt_alloc(sizeof(*ap) + len + 1, 4);
2030		if (!ap)
2031			continue;
2032		memset(ap, 0, sizeof(*ap) + len + 1);
2033		ap->alias = start;
2034		of_alias_add(ap, np, id, start, len);
2035	}
2036}
2037
2038/**
2039 * of_alias_get_id - Get alias id for the given device_node
2040 * @np:		Pointer to the given device_node
2041 * @stem:	Alias stem of the given device_node
2042 *
2043 * The function travels the lookup table to get alias id for the given
2044 * device_node and alias stem.  It returns the alias id if find it.
 
 
2045 */
2046int of_alias_get_id(struct device_node *np, const char *stem)
2047{
2048	struct alias_prop *app;
2049	int id = -ENODEV;
2050
2051	mutex_lock(&of_aliases_mutex);
2052	list_for_each_entry(app, &aliases_lookup, link) {
2053		if (strcmp(app->stem, stem) != 0)
2054			continue;
2055
2056		if (np == app->np) {
2057			id = app->id;
2058			break;
2059		}
2060	}
2061	mutex_unlock(&of_aliases_mutex);
2062
2063	return id;
2064}
2065EXPORT_SYMBOL_GPL(of_alias_get_id);
2066
2067const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
2068			       u32 *pu)
 
 
 
 
 
 
2069{
2070	const void *curv = cur;
 
2071
2072	if (!prop)
2073		return NULL;
 
 
2074
2075	if (!cur) {
2076		curv = prop->value;
2077		goto out_val;
2078	}
 
2079
2080	curv += sizeof(*cur);
2081	if (curv >= prop->value + prop->length)
2082		return NULL;
2083
2084out_val:
2085	*pu = be32_to_cpup(curv);
2086	return curv;
2087}
2088EXPORT_SYMBOL_GPL(of_prop_next_u32);
2089
2090const char *of_prop_next_string(struct property *prop, const char *cur)
2091{
2092	const void *curv = cur;
2093
2094	if (!prop)
2095		return NULL;
2096
2097	if (!cur)
2098		return prop->value;
2099
2100	curv += strlen(cur) + 1;
2101	if (curv >= prop->value + prop->length)
2102		return NULL;
2103
2104	return curv;
2105}
2106EXPORT_SYMBOL_GPL(of_prop_next_string);
2107
2108/**
2109 * of_device_is_stdout_path - check if a device node matches the
2110 *                            linux,stdout-path property
 
 
 
 
 
2111 *
2112 * Check if this device node matches the linux,stdout-path property
2113 * in the chosen node. return true if yes, false otherwise.
2114 */
2115int of_device_is_stdout_path(struct device_node *dn)
2116{
2117	if (!of_stdout)
2118		return false;
2119
2120	return of_stdout == dn;
 
 
 
 
2121}
2122EXPORT_SYMBOL_GPL(of_device_is_stdout_path);
2123
2124/**
2125 *	of_find_next_cache_node - Find a node's subsidiary cache
2126 *	@np:	node of type "cpu" or "cache"
2127 *
2128 *	Returns a node pointer with refcount incremented, use
2129 *	of_node_put() on it when done.  Caller should hold a reference
2130 *	to np.
2131 */
2132struct device_node *of_find_next_cache_node(const struct device_node *np)
2133{
2134	struct device_node *child;
2135	const phandle *handle;
2136
2137	handle = of_get_property(np, "l2-cache", NULL);
2138	if (!handle)
2139		handle = of_get_property(np, "next-level-cache", NULL);
2140
2141	if (handle)
2142		return of_find_node_by_phandle(be32_to_cpup(handle));
2143
2144	/* OF on pmac has nodes instead of properties named "l2-cache"
2145	 * beneath CPU nodes.
2146	 */
2147	if (!strcmp(np->type, "cpu"))
2148		for_each_child_of_node(np, child)
2149			if (!strcmp(child->type, "cache"))
2150				return child;
2151
2152	return NULL;
2153}
2154
2155/**
2156 * of_graph_parse_endpoint() - parse common endpoint node properties
2157 * @node: pointer to endpoint device_node
2158 * @endpoint: pointer to the OF endpoint data structure
 
2159 *
2160 * The caller should hold a reference to @node.
 
2161 */
2162int of_graph_parse_endpoint(const struct device_node *node,
2163			    struct of_endpoint *endpoint)
2164{
2165	struct device_node *port_node = of_get_parent(node);
2166
2167	WARN_ONCE(!port_node, "%s(): endpoint %s has no parent node\n",
2168		  __func__, node->full_name);
2169
2170	memset(endpoint, 0, sizeof(*endpoint));
2171
2172	endpoint->local_node = node;
2173	/*
2174	 * It doesn't matter whether the two calls below succeed.
2175	 * If they don't then the default value 0 is used.
2176	 */
2177	of_property_read_u32(port_node, "reg", &endpoint->port);
2178	of_property_read_u32(node, "reg", &endpoint->id);
2179
2180	of_node_put(port_node);
 
2181
2182	return 0;
2183}
2184EXPORT_SYMBOL(of_graph_parse_endpoint);
2185
2186/**
2187 * of_graph_get_next_endpoint() - get next endpoint node
2188 * @parent: pointer to the parent device node
2189 * @prev: previous endpoint node, or NULL to get first
 
 
 
 
2190 *
2191 * Return: An 'endpoint' node pointer with refcount incremented. Refcount
2192 * of the passed @prev node is not decremented, the caller have to use
2193 * of_node_put() on it when done.
 
 
 
 
 
 
2194 */
2195struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
2196					struct device_node *prev)
 
2197{
2198	struct device_node *endpoint;
2199	struct device_node *port;
2200
2201	if (!parent)
2202		return NULL;
2203
2204	/*
2205	 * Start by locating the port node. If no previous endpoint is specified
2206	 * search for the first port node, otherwise get the previous endpoint
2207	 * parent port node.
2208	 */
2209	if (!prev) {
2210		struct device_node *node;
2211
2212		node = of_get_child_by_name(parent, "ports");
2213		if (node)
2214			parent = node;
 
 
 
 
 
2215
2216		port = of_get_child_by_name(parent, "port");
2217		of_node_put(node);
 
 
 
2218
2219		if (!port) {
2220			pr_err("%s(): no port node found in %s\n",
2221			       __func__, parent->full_name);
2222			return NULL;
2223		}
2224	} else {
2225		port = of_get_parent(prev);
2226		if (WARN_ONCE(!port, "%s(): endpoint %s has no parent node\n",
2227			      __func__, prev->full_name))
2228			return NULL;
2229
2230		/*
2231		 * Avoid dropping prev node refcount to 0 when getting the next
2232		 * child below.
2233		 */
2234		of_node_get(prev);
2235	}
2236
2237	while (1) {
2238		/*
2239		 * Now that we have a port node, get the next endpoint by
2240		 * getting the next child. If the previous endpoint is NULL this
2241		 * will return the first child.
2242		 */
2243		endpoint = of_get_next_child(port, prev);
2244		if (endpoint) {
2245			of_node_put(port);
2246			return endpoint;
 
 
 
2247		}
2248
2249		/* No more endpoints under this port, try the next one. */
2250		prev = NULL;
2251
2252		do {
2253			port = of_get_next_child(parent, port);
2254			if (!port)
2255				return NULL;
2256		} while (of_node_cmp(port->name, "port"));
2257	}
2258}
2259EXPORT_SYMBOL(of_graph_get_next_endpoint);
 
2260
2261/**
2262 * of_graph_get_remote_port_parent() - get remote port's parent node
2263 * @node: pointer to a local endpoint device_node
2264 *
2265 * Return: Remote device node associated with remote endpoint node linked
2266 *	   to @node. Use of_node_put() on it when done.
2267 */
2268struct device_node *of_graph_get_remote_port_parent(
2269			       const struct device_node *node)
2270{
2271	struct device_node *np;
2272	unsigned int depth;
2273
2274	/* Get remote endpoint node. */
2275	np = of_parse_phandle(node, "remote-endpoint", 0);
2276
2277	/* Walk 3 levels up only if there is 'ports' node. */
2278	for (depth = 3; depth && np; depth--) {
2279		np = of_get_next_parent(np);
2280		if (depth == 2 && of_node_cmp(np->name, "ports"))
2281			break;
2282	}
2283	return np;
2284}
2285EXPORT_SYMBOL(of_graph_get_remote_port_parent);
2286
2287/**
2288 * of_graph_get_remote_port() - get remote port node
2289 * @node: pointer to a local endpoint device_node
2290 *
2291 * Return: Remote port node associated with remote endpoint node linked
2292 *	   to @node. Use of_node_put() on it when done.
2293 */
2294struct device_node *of_graph_get_remote_port(const struct device_node *node)
2295{
2296	struct device_node *np;
2297
2298	/* Get remote endpoint node. */
2299	np = of_parse_phandle(node, "remote-endpoint", 0);
2300	if (!np)
2301		return NULL;
2302	return of_get_next_parent(np);
2303}
2304EXPORT_SYMBOL(of_graph_get_remote_port);