1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Procedures for creating, accessing and interpreting the device tree.
   4 *
   5 * Paul Mackerras	August 1996.
   6 * Copyright (C) 1996-2005 Paul Mackerras.
   7 *
   8 *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
   9 *    {engebret|bergner}@us.ibm.com
  10 *
  11 *  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
  14 *  Grant Likely.
 
 
 
 
 
  15 */
  16
  17#define pr_fmt(fmt)	"OF: " fmt
  18
  19#include <linux/console.h>
  20#include <linux/ctype.h>
  21#include <linux/cpu.h>
  22#include <linux/module.h>
  23#include <linux/of.h>
  24#include <linux/of_device.h>
  25#include <linux/of_graph.h>
  26#include <linux/spinlock.h>
  27#include <linux/slab.h>
  28#include <linux/string.h>
  29#include <linux/proc_fs.h>
  30
  31#include "of_private.h"
  32
  33LIST_HEAD(aliases_lookup);
  34
  35struct device_node *of_root;
  36EXPORT_SYMBOL(of_root);
  37struct device_node *of_chosen;
  38EXPORT_SYMBOL(of_chosen);
  39struct device_node *of_aliases;
  40struct device_node *of_stdout;
  41static const char *of_stdout_options;
  42
  43struct kset *of_kset;
  44
  45/*
  46 * Used to protect the of_aliases, to hold off addition of nodes to sysfs.
  47 * This mutex must be held whenever modifications are being made to the
  48 * device tree. The of_{attach,detach}_node() and
  49 * of_{add,remove,update}_property() helpers make sure this happens.
  50 */
  51DEFINE_MUTEX(of_mutex);
  52
  53/* use when traversing tree through the child, sibling,
  54 * or parent members of struct device_node.
  55 */
  56DEFINE_RAW_SPINLOCK(devtree_lock);
  57
  58bool of_node_name_eq(const struct device_node *np, const char *name)
  59{
  60	const char *node_name;
  61	size_t len;
  62
  63	if (!np)
  64		return false;
  65
  66	node_name = kbasename(np->full_name);
  67	len = strchrnul(node_name, '@') - node_name;
  68
  69	return (strlen(name) == len) && (strncmp(node_name, name, len) == 0);
  70}
  71EXPORT_SYMBOL(of_node_name_eq);
  72
  73bool of_node_name_prefix(const struct device_node *np, const char *prefix)
  74{
  75	if (!np)
  76		return false;
  77
  78	return strncmp(kbasename(np->full_name), prefix, strlen(prefix)) == 0;
  79}
  80EXPORT_SYMBOL(of_node_name_prefix);
  81
  82static bool __of_node_is_type(const struct device_node *np, const char *type)
  83{
  84	const char *match = __of_get_property(np, "device_type", NULL);
  85
  86	return np && match && type && !strcmp(match, type);
  87}
  88
  89int of_bus_n_addr_cells(struct device_node *np)
  90{
  91	u32 cells;
  92
  93	for (; np; np = np->parent)
  94		if (!of_property_read_u32(np, "#address-cells", &cells))
  95			return cells;
  96
 
 
 
 
 
 
 
  97	/* No #address-cells property for the root node */
  98	return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
  99}
 100
 101int of_n_addr_cells(struct device_node *np)
 102{
 103	if (np->parent)
 104		np = np->parent;
 105
 106	return of_bus_n_addr_cells(np);
 107}
 108EXPORT_SYMBOL(of_n_addr_cells);
 109
 110int of_bus_n_size_cells(struct device_node *np)
 111{
 112	u32 cells;
 113
 114	for (; np; np = np->parent)
 115		if (!of_property_read_u32(np, "#size-cells", &cells))
 116			return cells;
 117
 
 
 
 
 
 
 
 118	/* No #size-cells property for the root node */
 119	return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
 120}
 121
 122int of_n_size_cells(struct device_node *np)
 123{
 124	if (np->parent)
 125		np = np->parent;
 126
 127	return of_bus_n_size_cells(np);
 128}
 129EXPORT_SYMBOL(of_n_size_cells);
 130
 131#ifdef CONFIG_NUMA
 132int __weak of_node_to_nid(struct device_node *np)
 
 
 
 
 
 
 
 133{
 134	return NUMA_NO_NODE;
 
 
 135}
 136#endif
 137
 138#define OF_PHANDLE_CACHE_BITS	7
 139#define OF_PHANDLE_CACHE_SZ	BIT(OF_PHANDLE_CACHE_BITS)
 140
 141static struct device_node *phandle_cache[OF_PHANDLE_CACHE_SZ];
 142
 143static u32 of_phandle_cache_hash(phandle handle)
 144{
 145	return hash_32(handle, OF_PHANDLE_CACHE_BITS);
 146}
 147
 148/*
 149 * Caller must hold devtree_lock.
 
 
 
 
 150 */
 151void __of_phandle_cache_inv_entry(phandle handle)
 152{
 153	u32 handle_hash;
 154	struct device_node *np;
 155
 156	if (!handle)
 
 
 
 
 157		return;
 
 158
 159	handle_hash = of_phandle_cache_hash(handle);
 160
 161	np = phandle_cache[handle_hash];
 162	if (np && handle == np->phandle)
 163		phandle_cache[handle_hash] = NULL;
 164}
 165
 166void __init of_core_init(void)
 167{
 168	struct device_node *np;
 169
 170	of_platform_register_reconfig_notifier();
 
 
 
 
 
 171
 172	/* Create the kset, and register existing nodes */
 173	mutex_lock(&of_mutex);
 174	of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
 175	if (!of_kset) {
 176		mutex_unlock(&of_mutex);
 177		pr_err("failed to register existing nodes\n");
 178		return;
 179	}
 180	for_each_of_allnodes(np) {
 181		__of_attach_node_sysfs(np);
 182		if (np->phandle && !phandle_cache[of_phandle_cache_hash(np->phandle)])
 183			phandle_cache[of_phandle_cache_hash(np->phandle)] = np;
 184	}
 185	mutex_unlock(&of_mutex);
 
 
 
 186
 187	/* Symlink in /proc as required by userspace ABI */
 188	if (of_root)
 189		proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
 
 
 
 
 
 
 
 190}
 
 
 191
 192static struct property *__of_find_property(const struct device_node *np,
 193					   const char *name, int *lenp)
 
 194{
 195	struct property *pp;
 196
 197	if (!np)
 198		return NULL;
 199
 200	for (pp = np->properties; pp; pp = pp->next) {
 
 201		if (of_prop_cmp(pp->name, name) == 0) {
 202			if (lenp)
 203				*lenp = pp->length;
 204			break;
 205		}
 206	}
 207
 208	return pp;
 209}
 210
 211struct property *of_find_property(const struct device_node *np,
 212				  const char *name,
 213				  int *lenp)
 214{
 215	struct property *pp;
 216	unsigned long flags;
 217
 218	raw_spin_lock_irqsave(&devtree_lock, flags);
 219	pp = __of_find_property(np, name, lenp);
 220	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 221
 222	return pp;
 223}
 224EXPORT_SYMBOL(of_find_property);
 225
 226struct device_node *__of_find_all_nodes(struct device_node *prev)
 227{
 228	struct device_node *np;
 229	if (!prev) {
 230		np = of_root;
 231	} else if (prev->child) {
 232		np = prev->child;
 233	} else {
 234		/* Walk back up looking for a sibling, or the end of the structure */
 235		np = prev;
 236		while (np->parent && !np->sibling)
 237			np = np->parent;
 238		np = np->sibling; /* Might be null at the end of the tree */
 239	}
 240	return np;
 241}
 242
 243/**
 244 * of_find_all_nodes - Get next node in global list
 245 * @prev:	Previous node or NULL to start iteration
 246 *		of_node_put() will be called on it
 247 *
 248 * Return: A node pointer with refcount incremented, use
 249 * of_node_put() on it when done.
 250 */
 251struct device_node *of_find_all_nodes(struct device_node *prev)
 252{
 253	struct device_node *np;
 254	unsigned long flags;
 255
 256	raw_spin_lock_irqsave(&devtree_lock, flags);
 257	np = __of_find_all_nodes(prev);
 258	of_node_get(np);
 
 
 259	of_node_put(prev);
 260	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 261	return np;
 262}
 263EXPORT_SYMBOL(of_find_all_nodes);
 264
 265/*
 266 * Find a property with a given name for a given node
 267 * and return the value.
 268 */
 269const void *__of_get_property(const struct device_node *np,
 270			      const char *name, int *lenp)
 271{
 272	struct property *pp = __of_find_property(np, name, lenp);
 273
 274	return pp ? pp->value : NULL;
 275}
 276
 277/*
 278 * Find a property with a given name for a given node
 279 * and return the value.
 280 */
 281const void *of_get_property(const struct device_node *np, const char *name,
 282			    int *lenp)
 283{
 284	struct property *pp = of_find_property(np, name, lenp);
 285
 286	return pp ? pp->value : NULL;
 287}
 288EXPORT_SYMBOL(of_get_property);
 289
 290/**
 291 * __of_device_is_compatible() - Check if the node matches given constraints
 292 * @device: pointer to node
 293 * @compat: required compatible string, NULL or "" for any match
 294 * @type: required device_type value, NULL or "" for any match
 295 * @name: required node name, NULL or "" for any match
 296 *
 297 * Checks if the given @compat, @type and @name strings match the
 298 * properties of the given @device. A constraints can be skipped by
 299 * passing NULL or an empty string as the constraint.
 300 *
 301 * Returns 0 for no match, and a positive integer on match. The return
 302 * value is a relative score with larger values indicating better
 303 * matches. The score is weighted for the most specific compatible value
 304 * to get the highest score. Matching type is next, followed by matching
 305 * name. Practically speaking, this results in the following priority
 306 * order for matches:
 307 *
 308 * 1. specific compatible && type && name
 309 * 2. specific compatible && type
 310 * 3. specific compatible && name
 311 * 4. specific compatible
 312 * 5. general compatible && type && name
 313 * 6. general compatible && type
 314 * 7. general compatible && name
 315 * 8. general compatible
 316 * 9. type && name
 317 * 10. type
 318 * 11. name
 319 */
 320static int __of_device_is_compatible(const struct device_node *device,
 321				     const char *compat, const char *type, const char *name)
 322{
 323	struct property *prop;
 324	const char *cp;
 325	int index = 0, score = 0;
 326
 327	/* Compatible match has highest priority */
 328	if (compat && compat[0]) {
 329		prop = __of_find_property(device, "compatible", NULL);
 330		for (cp = of_prop_next_string(prop, NULL); cp;
 331		     cp = of_prop_next_string(prop, cp), index++) {
 332			if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
 333				score = INT_MAX/2 - (index << 2);
 334				break;
 335			}
 336		}
 337		if (!score)
 338			return 0;
 339	}
 340
 341	/* Matching type is better than matching name */
 342	if (type && type[0]) {
 343		if (!__of_node_is_type(device, type))
 344			return 0;
 345		score += 2;
 346	}
 347
 348	/* Matching name is a bit better than not */
 349	if (name && name[0]) {
 350		if (!of_node_name_eq(device, name))
 351			return 0;
 352		score++;
 353	}
 354
 355	return score;
 356}
 357
 358/** Checks if the given "compat" string matches one of the strings in
 359 * the device's "compatible" property
 360 */
 361int of_device_is_compatible(const struct device_node *device,
 362		const char *compat)
 363{
 364	unsigned long flags;
 365	int res;
 366
 367	raw_spin_lock_irqsave(&devtree_lock, flags);
 368	res = __of_device_is_compatible(device, compat, NULL, NULL);
 369	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 370	return res;
 371}
 372EXPORT_SYMBOL(of_device_is_compatible);
 373
 374/** Checks if the device is compatible with any of the entries in
 375 *  a NULL terminated array of strings. Returns the best match
 376 *  score or 0.
 377 */
 378int of_device_compatible_match(const struct device_node *device,
 379			       const char *const *compat)
 380{
 381	unsigned int tmp, score = 0;
 382
 383	if (!compat)
 
 384		return 0;
 385
 386	while (*compat) {
 387		tmp = of_device_is_compatible(device, *compat);
 388		if (tmp > score)
 389			score = tmp;
 390		compat++;
 391	}
 392
 393	return score;
 394}
 395EXPORT_SYMBOL_GPL(of_device_compatible_match);
 396
 397/**
 398 * of_machine_is_compatible - Test root of device tree for a given compatible value
 399 * @compat: compatible string to look for in root node's compatible property.
 400 *
 401 * Return: A positive integer if the root node has the given value in its
 402 * compatible property.
 403 */
 404int of_machine_is_compatible(const char *compat)
 405{
 406	struct device_node *root;
 407	int rc = 0;
 408
 409	root = of_find_node_by_path("/");
 410	if (root) {
 411		rc = of_device_is_compatible(root, compat);
 412		of_node_put(root);
 413	}
 414	return rc;
 415}
 416EXPORT_SYMBOL(of_machine_is_compatible);
 417
 418/**
 419 *  __of_device_is_available - check if a device is available for use
 420 *
 421 *  @device: Node to check for availability, with locks already held
 422 *
 423 *  Return: True if the status property is absent or set to "okay" or "ok",
 424 *  false otherwise
 425 */
 426static bool __of_device_is_available(const struct device_node *device)
 427{
 428	const char *status;
 429	int statlen;
 430
 431	if (!device)
 432		return false;
 433
 434	status = __of_get_property(device, "status", &statlen);
 435	if (status == NULL)
 436		return true;
 437
 438	if (statlen > 0) {
 439		if (!strcmp(status, "okay") || !strcmp(status, "ok"))
 440			return true;
 441	}
 442
 443	return false;
 444}
 445
 446/**
 447 *  of_device_is_available - check if a device is available for use
 448 *
 449 *  @device: Node to check for availability
 450 *
 451 *  Return: True if the status property is absent or set to "okay" or "ok",
 452 *  false otherwise
 453 */
 454bool of_device_is_available(const struct device_node *device)
 455{
 456	unsigned long flags;
 457	bool res;
 458
 459	raw_spin_lock_irqsave(&devtree_lock, flags);
 460	res = __of_device_is_available(device);
 461	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 462	return res;
 463
 464}
 465EXPORT_SYMBOL(of_device_is_available);
 466
 467/**
 468 *  __of_device_is_fail - check if a device has status "fail" or "fail-..."
 469 *
 470 *  @device: Node to check status for, with locks already held
 471 *
 472 *  Return: True if the status property is set to "fail" or "fail-..." (for any
 473 *  error code suffix), false otherwise
 474 */
 475static bool __of_device_is_fail(const struct device_node *device)
 476{
 477	const char *status;
 478
 479	if (!device)
 480		return false;
 481
 482	status = __of_get_property(device, "status", NULL);
 483	if (status == NULL)
 484		return false;
 485
 486	return !strcmp(status, "fail") || !strncmp(status, "fail-", 5);
 487}
 488
 489/**
 490 *  of_device_is_big_endian - check if a device has BE registers
 491 *
 492 *  @device: Node to check for endianness
 493 *
 494 *  Return: True if the device has a "big-endian" property, or if the kernel
 495 *  was compiled for BE *and* the device has a "native-endian" property.
 496 *  Returns false otherwise.
 497 *
 498 *  Callers would nominally use ioread32be/iowrite32be if
 499 *  of_device_is_big_endian() == true, or readl/writel otherwise.
 500 */
 501bool of_device_is_big_endian(const struct device_node *device)
 502{
 503	if (of_property_read_bool(device, "big-endian"))
 504		return true;
 505	if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&
 506	    of_property_read_bool(device, "native-endian"))
 507		return true;
 508	return false;
 509}
 510EXPORT_SYMBOL(of_device_is_big_endian);
 511
 512/**
 513 * of_get_parent - Get a node's parent if any
 514 * @node:	Node to get parent
 515 *
 516 * Return: A node pointer with refcount incremented, use
 517 * of_node_put() on it when done.
 518 */
 519struct device_node *of_get_parent(const struct device_node *node)
 520{
 521	struct device_node *np;
 522	unsigned long flags;
 523
 524	if (!node)
 525		return NULL;
 526
 527	raw_spin_lock_irqsave(&devtree_lock, flags);
 528	np = of_node_get(node->parent);
 529	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 530	return np;
 531}
 532EXPORT_SYMBOL(of_get_parent);
 533
 534/**
 535 * of_get_next_parent - Iterate to a node's parent
 536 * @node:	Node to get parent of
 537 *
 538 * This is like of_get_parent() except that it drops the
 539 * refcount on the passed node, making it suitable for iterating
 540 * through a node's parents.
 541 *
 542 * Return: A node pointer with refcount incremented, use
 543 * of_node_put() on it when done.
 544 */
 545struct device_node *of_get_next_parent(struct device_node *node)
 546{
 547	struct device_node *parent;
 548	unsigned long flags;
 549
 550	if (!node)
 551		return NULL;
 552
 553	raw_spin_lock_irqsave(&devtree_lock, flags);
 554	parent = of_node_get(node->parent);
 555	of_node_put(node);
 556	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 557	return parent;
 558}
 559EXPORT_SYMBOL(of_get_next_parent);
 560
 561static struct device_node *__of_get_next_child(const struct device_node *node,
 562						struct device_node *prev)
 563{
 564	struct device_node *next;
 565
 566	if (!node)
 567		return NULL;
 568
 569	next = prev ? prev->sibling : node->child;
 570	of_node_get(next);
 571	of_node_put(prev);
 572	return next;
 573}
 574#define __for_each_child_of_node(parent, child) \
 575	for (child = __of_get_next_child(parent, NULL); child != NULL; \
 576	     child = __of_get_next_child(parent, child))
 577
 578/**
 579 * of_get_next_child - Iterate a node childs
 580 * @node:	parent node
 581 * @prev:	previous child of the parent node, or NULL to get first
 582 *
 583 * Return: A node pointer with refcount incremented, use of_node_put() on
 584 * it when done. Returns NULL when prev is the last child. Decrements the
 585 * refcount of prev.
 586 */
 587struct device_node *of_get_next_child(const struct device_node *node,
 588	struct device_node *prev)
 589{
 590	struct device_node *next;
 591	unsigned long flags;
 592
 593	raw_spin_lock_irqsave(&devtree_lock, flags);
 594	next = __of_get_next_child(node, prev);
 595	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 596	return next;
 597}
 598EXPORT_SYMBOL(of_get_next_child);
 599
 600/**
 601 * of_get_next_available_child - Find the next available child node
 602 * @node:	parent node
 603 * @prev:	previous child of the parent node, or NULL to get first
 604 *
 605 * This function is like of_get_next_child(), except that it
 606 * automatically skips any disabled nodes (i.e. status = "disabled").
 607 */
 608struct device_node *of_get_next_available_child(const struct device_node *node,
 609	struct device_node *prev)
 610{
 611	struct device_node *next;
 612	unsigned long flags;
 613
 614	if (!node)
 615		return NULL;
 616
 617	raw_spin_lock_irqsave(&devtree_lock, flags);
 618	next = prev ? prev->sibling : node->child;
 619	for (; next; next = next->sibling) {
 620		if (!__of_device_is_available(next))
 621			continue;
 622		if (of_node_get(next))
 623			break;
 624	}
 625	of_node_put(prev);
 626	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 627	return next;
 628}
 629EXPORT_SYMBOL(of_get_next_available_child);
 630
 631/**
 632 * of_get_next_cpu_node - Iterate on cpu nodes
 633 * @prev:	previous child of the /cpus node, or NULL to get first
 634 *
 635 * Unusable CPUs (those with the status property set to "fail" or "fail-...")
 636 * will be skipped.
 637 *
 638 * Return: A cpu node pointer with refcount incremented, use of_node_put()
 639 * on it when done. Returns NULL when prev is the last child. Decrements
 640 * the refcount of prev.
 641 */
 642struct device_node *of_get_next_cpu_node(struct device_node *prev)
 643{
 644	struct device_node *next = NULL;
 645	unsigned long flags;
 646	struct device_node *node;
 647
 648	if (!prev)
 649		node = of_find_node_by_path("/cpus");
 650
 651	raw_spin_lock_irqsave(&devtree_lock, flags);
 652	if (prev)
 653		next = prev->sibling;
 654	else if (node) {
 655		next = node->child;
 656		of_node_put(node);
 657	}
 658	for (; next; next = next->sibling) {
 659		if (__of_device_is_fail(next))
 660			continue;
 661		if (!(of_node_name_eq(next, "cpu") ||
 662		      __of_node_is_type(next, "cpu")))
 663			continue;
 664		if (of_node_get(next))
 665			break;
 666	}
 667	of_node_put(prev);
 668	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 669	return next;
 670}
 671EXPORT_SYMBOL(of_get_next_cpu_node);
 672
 673/**
 674 * of_get_compatible_child - Find compatible child node
 675 * @parent:	parent node
 676 * @compatible:	compatible string
 677 *
 678 * Lookup child node whose compatible property contains the given compatible
 679 * string.
 680 *
 681 * Return: a node pointer with refcount incremented, use of_node_put() on it
 682 * when done; or NULL if not found.
 683 */
 684struct device_node *of_get_compatible_child(const struct device_node *parent,
 685				const char *compatible)
 686{
 687	struct device_node *child;
 688
 689	for_each_child_of_node(parent, child) {
 690		if (of_device_is_compatible(child, compatible))
 691			break;
 692	}
 693
 694	return child;
 695}
 696EXPORT_SYMBOL(of_get_compatible_child);
 697
 698/**
 699 * of_get_child_by_name - Find the child node by name for a given parent
 700 * @node:	parent node
 701 * @name:	child name to look for.
 702 *
 703 * This function looks for child node for given matching name
 704 *
 705 * Return: A node pointer if found, with refcount incremented, use
 706 * of_node_put() on it when done.
 707 * Returns NULL if node is not found.
 708 */
 709struct device_node *of_get_child_by_name(const struct device_node *node,
 710				const char *name)
 711{
 712	struct device_node *child;
 713
 714	for_each_child_of_node(node, child)
 715		if (of_node_name_eq(child, name))
 716			break;
 717	return child;
 718}
 719EXPORT_SYMBOL(of_get_child_by_name);
 720
 721struct device_node *__of_find_node_by_path(struct device_node *parent,
 722						const char *path)
 723{
 724	struct device_node *child;
 725	int len;
 726
 727	len = strcspn(path, "/:");
 728	if (!len)
 729		return NULL;
 730
 731	__for_each_child_of_node(parent, child) {
 732		const char *name = kbasename(child->full_name);
 733		if (strncmp(path, name, len) == 0 && (strlen(name) == len))
 734			return child;
 735	}
 736	return NULL;
 737}
 738
 739struct device_node *__of_find_node_by_full_path(struct device_node *node,
 740						const char *path)
 741{
 742	const char *separator = strchr(path, ':');
 743
 744	while (node && *path == '/') {
 745		struct device_node *tmp = node;
 746
 747		path++; /* Increment past '/' delimiter */
 748		node = __of_find_node_by_path(node, path);
 749		of_node_put(tmp);
 750		path = strchrnul(path, '/');
 751		if (separator && separator < path)
 752			break;
 753	}
 754	return node;
 755}
 756
 757/**
 758 * of_find_node_opts_by_path - Find a node matching a full OF path
 759 * @path: Either the full path to match, or if the path does not
 760 *       start with '/', the name of a property of the /aliases
 761 *       node (an alias).  In the case of an alias, the node
 762 *       matching the alias' value will be returned.
 763 * @opts: Address of a pointer into which to store the start of
 764 *       an options string appended to the end of the path with
 765 *       a ':' separator.
 766 *
 767 * Valid paths:
 768 *  * /foo/bar	Full path
 769 *  * foo	Valid alias
 770 *  * foo/bar	Valid alias + relative path
 771 *
 772 * Return: A node pointer with refcount incremented, use
 773 * of_node_put() on it when done.
 774 */
 775struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
 776{
 777	struct device_node *np = NULL;
 778	struct property *pp;
 779	unsigned long flags;
 780	const char *separator = strchr(path, ':');
 781
 782	if (opts)
 783		*opts = separator ? separator + 1 : NULL;
 784
 785	if (strcmp(path, "/") == 0)
 786		return of_node_get(of_root);
 787
 788	/* The path could begin with an alias */
 789	if (*path != '/') {
 790		int len;
 791		const char *p = separator;
 792
 793		if (!p)
 794			p = strchrnul(path, '/');
 795		len = p - path;
 796
 797		/* of_aliases must not be NULL */
 798		if (!of_aliases)
 799			return NULL;
 800
 801		for_each_property_of_node(of_aliases, pp) {
 802			if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) {
 803				np = of_find_node_by_path(pp->value);
 804				break;
 805			}
 806		}
 807		if (!np)
 808			return NULL;
 809		path = p;
 810	}
 811
 812	/* Step down the tree matching path components */
 813	raw_spin_lock_irqsave(&devtree_lock, flags);
 814	if (!np)
 815		np = of_node_get(of_root);
 816	np = __of_find_node_by_full_path(np, path);
 817	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 818	return np;
 819}
 820EXPORT_SYMBOL(of_find_node_opts_by_path);
 821
 822/**
 823 * of_find_node_by_name - Find a node by its "name" property
 824 * @from:	The node to start searching from or NULL; the node
 825 *		you pass will not be searched, only the next one
 826 *		will. Typically, you pass what the previous call
 827 *		returned. of_node_put() will be called on @from.
 828 * @name:	The name string to match against
 829 *
 830 * Return: A node pointer with refcount incremented, use
 831 * of_node_put() on it when done.
 832 */
 833struct device_node *of_find_node_by_name(struct device_node *from,
 834	const char *name)
 835{
 836	struct device_node *np;
 837	unsigned long flags;
 838
 839	raw_spin_lock_irqsave(&devtree_lock, flags);
 840	for_each_of_allnodes_from(from, np)
 841		if (of_node_name_eq(np, name) && of_node_get(np))
 
 
 842			break;
 843	of_node_put(from);
 844	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 845	return np;
 846}
 847EXPORT_SYMBOL(of_find_node_by_name);
 848
 849/**
 850 * of_find_node_by_type - Find a node by its "device_type" property
 851 * @from:	The node to start searching from, or NULL to start searching
 852 *		the entire device tree. The node you pass will not be
 853 *		searched, only the next one will; typically, you pass
 854 *		what the previous call returned. of_node_put() will be
 855 *		called on from for you.
 856 * @type:	The type string to match against
 857 *
 858 * Return: A node pointer with refcount incremented, use
 859 * of_node_put() on it when done.
 860 */
 861struct device_node *of_find_node_by_type(struct device_node *from,
 862	const char *type)
 863{
 864	struct device_node *np;
 865	unsigned long flags;
 866
 867	raw_spin_lock_irqsave(&devtree_lock, flags);
 868	for_each_of_allnodes_from(from, np)
 869		if (__of_node_is_type(np, type) && of_node_get(np))
 
 
 870			break;
 871	of_node_put(from);
 872	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 873	return np;
 874}
 875EXPORT_SYMBOL(of_find_node_by_type);
 876
 877/**
 878 * of_find_compatible_node - Find a node based on type and one of the
 879 *                                tokens in its "compatible" property
 880 * @from:	The node to start searching from or NULL, the node
 881 *		you pass will not be searched, only the next one
 882 *		will; typically, you pass what the previous call
 883 *		returned. of_node_put() will be called on it
 884 * @type:	The type string to match "device_type" or NULL to ignore
 885 * @compatible:	The string to match to one of the tokens in the device
 886 *		"compatible" list.
 887 *
 888 * Return: A node pointer with refcount incremented, use
 889 * of_node_put() on it when done.
 890 */
 891struct device_node *of_find_compatible_node(struct device_node *from,
 892	const char *type, const char *compatible)
 893{
 894	struct device_node *np;
 895	unsigned long flags;
 896
 897	raw_spin_lock_irqsave(&devtree_lock, flags);
 898	for_each_of_allnodes_from(from, np)
 899		if (__of_device_is_compatible(np, compatible, type, NULL) &&
 900		    of_node_get(np))
 
 
 
 901			break;
 
 902	of_node_put(from);
 903	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 904	return np;
 905}
 906EXPORT_SYMBOL(of_find_compatible_node);
 907
 908/**
 909 * of_find_node_with_property - Find a node which has a property with
 910 *                              the given name.
 911 * @from:	The node to start searching from or NULL, the node
 912 *		you pass will not be searched, only the next one
 913 *		will; typically, you pass what the previous call
 914 *		returned. of_node_put() will be called on it
 915 * @prop_name:	The name of the property to look for.
 916 *
 917 * Return: A node pointer with refcount incremented, use
 918 * of_node_put() on it when done.
 919 */
 920struct device_node *of_find_node_with_property(struct device_node *from,
 921	const char *prop_name)
 922{
 923	struct device_node *np;
 924	struct property *pp;
 925	unsigned long flags;
 926
 927	raw_spin_lock_irqsave(&devtree_lock, flags);
 928	for_each_of_allnodes_from(from, np) {
 929		for (pp = np->properties; pp; pp = pp->next) {
 
 930			if (of_prop_cmp(pp->name, prop_name) == 0) {
 931				of_node_get(np);
 932				goto out;
 933			}
 934		}
 935	}
 936out:
 937	of_node_put(from);
 938	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 939	return np;
 940}
 941EXPORT_SYMBOL(of_find_node_with_property);
 942
 943static
 944const struct of_device_id *__of_match_node(const struct of_device_id *matches,
 945					   const struct device_node *node)
 946{
 947	const struct of_device_id *best_match = NULL;
 948	int score, best_score = 0;
 949
 950	if (!matches)
 951		return NULL;
 952
 953	for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
 954		score = __of_device_is_compatible(node, matches->compatible,
 955						  matches->type, matches->name);
 956		if (score > best_score) {
 957			best_match = matches;
 958			best_score = score;
 959		}
 960	}
 961
 962	return best_match;
 963}
 964
 965/**
 966 * of_match_node - Tell if a device_node has a matching of_match structure
 967 * @matches:	array of of device match structures to search in
 968 * @node:	the of device structure to match against
 969 *
 970 * Low level utility function used by device matching.
 971 */
 972const struct of_device_id *of_match_node(const struct of_device_id *matches,
 973					 const struct device_node *node)
 974{
 975	const struct of_device_id *match;
 976	unsigned long flags;
 977
 978	raw_spin_lock_irqsave(&devtree_lock, flags);
 979	match = __of_match_node(matches, node);
 980	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 981	return match;
 
 
 
 
 
 
 
 
 
 
 
 
 982}
 983EXPORT_SYMBOL(of_match_node);
 984
 985/**
 986 * of_find_matching_node_and_match - Find a node based on an of_device_id
 987 *				     match table.
 988 * @from:	The node to start searching from or NULL, the node
 989 *		you pass will not be searched, only the next one
 990 *		will; typically, you pass what the previous call
 991 *		returned. of_node_put() will be called on it
 992 * @matches:	array of of device match structures to search in
 993 * @match:	Updated to point at the matches entry which matched
 994 *
 995 * Return: A node pointer with refcount incremented, use
 996 * of_node_put() on it when done.
 997 */
 998struct device_node *of_find_matching_node_and_match(struct device_node *from,
 999					const struct of_device_id *matches,
1000					const struct of_device_id **match)
1001{
1002	struct device_node *np;
1003	const struct of_device_id *m;
1004	unsigned long flags;
1005
1006	if (match)
1007		*match = NULL;
1008
1009	raw_spin_lock_irqsave(&devtree_lock, flags);
1010	for_each_of_allnodes_from(from, np) {
1011		m = __of_match_node(matches, np);
1012		if (m && of_node_get(np)) {
1013			if (match)
1014				*match = m;
1015			break;
1016		}
1017	}
1018	of_node_put(from);
1019	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1020	return np;
1021}
1022EXPORT_SYMBOL(of_find_matching_node_and_match);
1023
1024/**
1025 * of_alias_from_compatible - Lookup appropriate alias for a device node
1026 *			      depending on compatible
1027 * @node:	pointer to a device tree node
1028 * @alias:	Pointer to buffer that alias value will be copied into
1029 * @len:	Length of alias value
1030 *
1031 * Based on the value of the compatible property, this routine will attempt
1032 * to choose an appropriate alias value for a particular device tree node.
1033 * It does this by stripping the manufacturer prefix (as delimited by a ',')
1034 * from the first entry in the compatible list property.
1035 *
1036 * Note: The matching on just the "product" side of the compatible is a relic
1037 * from I2C and SPI. Please do not add any new user.
1038 *
1039 * Return: This routine returns 0 on success, <0 on failure.
1040 */
1041int of_alias_from_compatible(const struct device_node *node, char *alias, int len)
1042{
1043	const char *compatible, *p;
1044	int cplen;
1045
1046	compatible = of_get_property(node, "compatible", &cplen);
1047	if (!compatible || strlen(compatible) > cplen)
1048		return -ENODEV;
1049	p = strchr(compatible, ',');
1050	strscpy(alias, p ? p + 1 : compatible, len);
1051	return 0;
1052}
1053EXPORT_SYMBOL_GPL(of_alias_from_compatible);
1054
1055/**
1056 * of_find_node_by_phandle - Find a node given a phandle
1057 * @handle:	phandle of the node to find
1058 *
1059 * Return: A node pointer with refcount incremented, use
1060 * of_node_put() on it when done.
1061 */
1062struct device_node *of_find_node_by_phandle(phandle handle)
1063{
1064	struct device_node *np = NULL;
1065	unsigned long flags;
1066	u32 handle_hash;
1067
1068	if (!handle)
1069		return NULL;
1070
1071	handle_hash = of_phandle_cache_hash(handle);
1072
1073	raw_spin_lock_irqsave(&devtree_lock, flags);
1074
1075	if (phandle_cache[handle_hash] &&
1076	    handle == phandle_cache[handle_hash]->phandle)
1077		np = phandle_cache[handle_hash];
1078
1079	if (!np) {
1080		for_each_of_allnodes(np)
1081			if (np->phandle == handle &&
1082			    !of_node_check_flag(np, OF_DETACHED)) {
1083				phandle_cache[handle_hash] = np;
1084				break;
1085			}
1086	}
1087
 
 
 
 
1088	of_node_get(np);
1089	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1090	return np;
1091}
1092EXPORT_SYMBOL(of_find_node_by_phandle);
1093
1094void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
1095{
1096	int i;
1097	printk("%s %pOF", msg, args->np);
1098	for (i = 0; i < args->args_count; i++) {
1099		const char delim = i ? ',' : ':';
1100
1101		pr_cont("%c%08x", delim, args->args[i]);
1102	}
1103	pr_cont("\n");
1104}
1105
1106int of_phandle_iterator_init(struct of_phandle_iterator *it,
1107		const struct device_node *np,
1108		const char *list_name,
1109		const char *cells_name,
1110		int cell_count)
 
1111{
1112	const __be32 *list;
1113	int size;
1114
1115	memset(it, 0, sizeof(*it));
1116
1117	/*
1118	 * one of cell_count or cells_name must be provided to determine the
1119	 * argument length.
1120	 */
1121	if (cell_count < 0 && !cells_name)
1122		return -EINVAL;
1123
1124	list = of_get_property(np, list_name, &size);
1125	if (!list)
1126		return -ENOENT;
1127
1128	it->cells_name = cells_name;
1129	it->cell_count = cell_count;
1130	it->parent = np;
1131	it->list_end = list + size / sizeof(*list);
1132	it->phandle_end = list;
1133	it->cur = list;
1134
1135	return 0;
1136}
1137EXPORT_SYMBOL_GPL(of_phandle_iterator_init);
1138
1139int of_phandle_iterator_next(struct of_phandle_iterator *it)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1140{
1141	uint32_t count = 0;
1142
1143	if (it->node) {
1144		of_node_put(it->node);
1145		it->node = NULL;
1146	}
1147
1148	if (!it->cur || it->phandle_end >= it->list_end)
1149		return -ENOENT;
1150
1151	it->cur = it->phandle_end;
1152
1153	/* If phandle is 0, then it is an empty entry with no arguments. */
1154	it->phandle = be32_to_cpup(it->cur++);
1155
1156	if (it->phandle) {
1157
1158		/*
1159		 * Find the provider node and parse the #*-cells property to
1160		 * determine the argument length.
1161		 */
1162		it->node = of_find_node_by_phandle(it->phandle);
1163
1164		if (it->cells_name) {
1165			if (!it->node) {
1166				pr_err("%pOF: could not find phandle %d\n",
1167				       it->parent, it->phandle);
1168				goto err;
1169			}
1170
1171			if (of_property_read_u32(it->node, it->cells_name,
1172						 &count)) {
1173				/*
1174				 * If both cell_count and cells_name is given,
1175				 * fall back to cell_count in absence
1176				 * of the cells_name property
1177				 */
1178				if (it->cell_count >= 0) {
1179					count = it->cell_count;
1180				} else {
1181					pr_err("%pOF: could not get %s for %pOF\n",
1182					       it->parent,
1183					       it->cells_name,
1184					       it->node);
1185					goto err;
1186				}
1187			}
1188		} else {
1189			count = it->cell_count;
1190		}
1191
1192		/*
1193		 * Make sure that the arguments actually fit in the remaining
1194		 * property data length
1195		 */
1196		if (it->cur + count > it->list_end) {
1197			if (it->cells_name)
1198				pr_err("%pOF: %s = %d found %td\n",
1199					it->parent, it->cells_name,
1200					count, it->list_end - it->cur);
1201			else
1202				pr_err("%pOF: phandle %s needs %d, found %td\n",
1203					it->parent, of_node_full_name(it->node),
1204					count, it->list_end - it->cur);
1205			goto err;
1206		}
1207	}
1208
1209	it->phandle_end = it->cur + count;
1210	it->cur_count = count;
1211
1212	return 0;
1213
1214err:
1215	if (it->node) {
1216		of_node_put(it->node);
1217		it->node = NULL;
1218	}
1219
1220	return -EINVAL;
1221}
1222EXPORT_SYMBOL_GPL(of_phandle_iterator_next);
1223
1224int of_phandle_iterator_args(struct of_phandle_iterator *it,
1225			     uint32_t *args,
1226			     int size)
1227{
1228	int i, count;
1229
1230	count = it->cur_count;
1231
1232	if (WARN_ON(size < count))
1233		count = size;
1234
1235	for (i = 0; i < count; i++)
1236		args[i] = be32_to_cpup(it->cur++);
1237
1238	return count;
1239}
1240
1241int __of_parse_phandle_with_args(const struct device_node *np,
1242				 const char *list_name,
1243				 const char *cells_name,
1244				 int cell_count, int index,
1245				 struct of_phandle_args *out_args)
 
1246{
1247	struct of_phandle_iterator it;
1248	int rc, cur_index = 0;
1249
1250	if (index < 0)
1251		return -EINVAL;
1252
1253	/* Loop over the phandles until all the requested entry is found */
1254	of_for_each_phandle(&it, rc, np, list_name, cells_name, cell_count) {
1255		/*
1256		 * All of the error cases bail out of the loop, so at
1257		 * this point, the parsing is successful. If the requested
1258		 * index matches, then fill the out_args structure and return,
1259		 * or return -ENOENT for an empty entry.
1260		 */
1261		rc = -ENOENT;
1262		if (cur_index == index) {
1263			if (!it.phandle)
1264				goto err;
1265
1266			if (out_args) {
1267				int c;
1268
1269				c = of_phandle_iterator_args(&it,
1270							     out_args->args,
1271							     MAX_PHANDLE_ARGS);
1272				out_args->np = it.node;
1273				out_args->args_count = c;
1274			} else {
1275				of_node_put(it.node);
1276			}
1277
1278			/* Found it! return success */
1279			return 0;
1280		}
1281
1282		cur_index++;
1283	}
1284
1285	/*
1286	 * Unlock node before returning result; will be one of:
1287	 * -ENOENT : index is for empty phandle
1288	 * -EINVAL : parsing error on data
1289	 */
1290
1291 err:
1292	of_node_put(it.node);
1293	return rc;
1294}
1295EXPORT_SYMBOL(__of_parse_phandle_with_args);
1296
1297/**
1298 * of_parse_phandle_with_args_map() - Find a node pointed by phandle in a list and remap it
1299 * @np:		pointer to a device tree node containing a list
1300 * @list_name:	property name that contains a list
1301 * @stem_name:	stem of property names that specify phandles' arguments count
1302 * @index:	index of a phandle to parse out
1303 * @out_args:	optional pointer to output arguments structure (will be filled)
 
1304 *
1305 * This function is useful to parse lists of phandles and their arguments.
1306 * Returns 0 on success and fills out_args, on error returns appropriate errno
1307 * value. The difference between this function and of_parse_phandle_with_args()
1308 * is that this API remaps a phandle if the node the phandle points to has
1309 * a <@stem_name>-map property.
1310 *
1311 * Caller is responsible to call of_node_put() on the returned out_args->np
1312 * pointer.
1313 *
1314 * Example::
1315 *
1316 *  phandle1: node1 {
1317 *  	#list-cells = <2>;
1318 *  };
1319 *
1320 *  phandle2: node2 {
1321 *  	#list-cells = <1>;
1322 *  };
1323 *
1324 *  phandle3: node3 {
1325 *  	#list-cells = <1>;
1326 *  	list-map = <0 &phandle2 3>,
1327 *  		   <1 &phandle2 2>,
1328 *  		   <2 &phandle1 5 1>;
1329 *  	list-map-mask = <0x3>;
1330 *  };
1331 *
1332 *  node4 {
1333 *  	list = <&phandle1 1 2 &phandle3 0>;
1334 *  };
1335 *
1336 * To get a device_node of the ``node2`` node you may call this:
1337 * of_parse_phandle_with_args(node4, "list", "list", 1, &args);
1338 */
1339int of_parse_phandle_with_args_map(const struct device_node *np,
1340				   const char *list_name,
1341				   const char *stem_name,
1342				   int index, struct of_phandle_args *out_args)
1343{
1344	char *cells_name, *map_name = NULL, *mask_name = NULL;
1345	char *pass_name = NULL;
1346	struct device_node *cur, *new = NULL;
1347	const __be32 *map, *mask, *pass;
1348	static const __be32 dummy_mask[] = { [0 ... MAX_PHANDLE_ARGS] = ~0 };
1349	static const __be32 dummy_pass[] = { [0 ... MAX_PHANDLE_ARGS] = 0 };
1350	__be32 initial_match_array[MAX_PHANDLE_ARGS];
1351	const __be32 *match_array = initial_match_array;
1352	int i, ret, map_len, match;
1353	u32 list_size, new_size;
1354
1355	if (index < 0)
1356		return -EINVAL;
1357
1358	cells_name = kasprintf(GFP_KERNEL, "#%s-cells", stem_name);
1359	if (!cells_name)
1360		return -ENOMEM;
1361
1362	ret = -ENOMEM;
1363	map_name = kasprintf(GFP_KERNEL, "%s-map", stem_name);
1364	if (!map_name)
1365		goto free;
1366
1367	mask_name = kasprintf(GFP_KERNEL, "%s-map-mask", stem_name);
1368	if (!mask_name)
1369		goto free;
1370
1371	pass_name = kasprintf(GFP_KERNEL, "%s-map-pass-thru", stem_name);
1372	if (!pass_name)
1373		goto free;
1374
1375	ret = __of_parse_phandle_with_args(np, list_name, cells_name, -1, index,
1376					   out_args);
1377	if (ret)
1378		goto free;
1379
1380	/* Get the #<list>-cells property */
1381	cur = out_args->np;
1382	ret = of_property_read_u32(cur, cells_name, &list_size);
1383	if (ret < 0)
1384		goto put;
1385
1386	/* Precalculate the match array - this simplifies match loop */
1387	for (i = 0; i < list_size; i++)
1388		initial_match_array[i] = cpu_to_be32(out_args->args[i]);
1389
1390	ret = -EINVAL;
1391	while (cur) {
1392		/* Get the <list>-map property */
1393		map = of_get_property(cur, map_name, &map_len);
1394		if (!map) {
1395			ret = 0;
1396			goto free;
1397		}
1398		map_len /= sizeof(u32);
1399
1400		/* Get the <list>-map-mask property (optional) */
1401		mask = of_get_property(cur, mask_name, NULL);
1402		if (!mask)
1403			mask = dummy_mask;
1404		/* Iterate through <list>-map property */
1405		match = 0;
1406		while (map_len > (list_size + 1) && !match) {
1407			/* Compare specifiers */
1408			match = 1;
1409			for (i = 0; i < list_size; i++, map_len--)
1410				match &= !((match_array[i] ^ *map++) & mask[i]);
1411
1412			of_node_put(new);
1413			new = of_find_node_by_phandle(be32_to_cpup(map));
1414			map++;
1415			map_len--;
1416
1417			/* Check if not found */
1418			if (!new)
1419				goto put;
1420
1421			if (!of_device_is_available(new))
1422				match = 0;
1423
1424			ret = of_property_read_u32(new, cells_name, &new_size);
1425			if (ret)
1426				goto put;
1427
1428			/* Check for malformed properties */
1429			if (WARN_ON(new_size > MAX_PHANDLE_ARGS))
1430				goto put;
1431			if (map_len < new_size)
1432				goto put;
1433
1434			/* Move forward by new node's #<list>-cells amount */
1435			map += new_size;
1436			map_len -= new_size;
1437		}
1438		if (!match)
1439			goto put;
1440
1441		/* Get the <list>-map-pass-thru property (optional) */
1442		pass = of_get_property(cur, pass_name, NULL);
1443		if (!pass)
1444			pass = dummy_pass;
1445
1446		/*
1447		 * Successfully parsed a <list>-map translation; copy new
1448		 * specifier into the out_args structure, keeping the
1449		 * bits specified in <list>-map-pass-thru.
1450		 */
1451		match_array = map - new_size;
1452		for (i = 0; i < new_size; i++) {
1453			__be32 val = *(map - new_size + i);
1454
1455			if (i < list_size) {
1456				val &= ~pass[i];
1457				val |= cpu_to_be32(out_args->args[i]) & pass[i];
1458			}
1459
1460			out_args->args[i] = be32_to_cpu(val);
 
 
 
 
1461		}
1462		out_args->args_count = list_size = new_size;
1463		/* Iterate again with new provider */
1464		out_args->np = new;
1465		of_node_put(cur);
1466		cur = new;
1467		new = NULL;
1468	}
1469put:
1470	of_node_put(cur);
1471	of_node_put(new);
1472free:
1473	kfree(mask_name);
1474	kfree(map_name);
1475	kfree(cells_name);
1476	kfree(pass_name);
1477
1478	return ret;
1479}
1480EXPORT_SYMBOL(of_parse_phandle_with_args_map);
 
 
 
1481
1482/**
1483 * of_count_phandle_with_args() - Find the number of phandles references in a property
1484 * @np:		pointer to a device tree node containing a list
1485 * @list_name:	property name that contains a list
1486 * @cells_name:	property name that specifies phandles' arguments count
1487 *
1488 * Return: The number of phandle + argument tuples within a property. It
1489 * is a typical pattern to encode a list of phandle and variable
1490 * arguments into a single property. The number of arguments is encoded
1491 * by a property in the phandle-target node. For example, a gpios
1492 * property would contain a list of GPIO specifies consisting of a
1493 * phandle and 1 or more arguments. The number of arguments are
1494 * determined by the #gpio-cells property in the node pointed to by the
1495 * phandle.
1496 */
1497int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
1498				const char *cells_name)
1499{
1500	struct of_phandle_iterator it;
1501	int rc, cur_index = 0;
1502
1503	/*
1504	 * If cells_name is NULL we assume a cell count of 0. This makes
1505	 * counting the phandles trivial as each 32bit word in the list is a
1506	 * phandle and no arguments are to consider. So we don't iterate through
1507	 * the list but just use the length to determine the phandle count.
1508	 */
1509	if (!cells_name) {
1510		const __be32 *list;
1511		int size;
1512
1513		list = of_get_property(np, list_name, &size);
1514		if (!list)
1515			return -ENOENT;
1516
1517		return size / sizeof(*list);
 
 
 
1518	}
1519
1520	rc = of_phandle_iterator_init(&it, np, list_name, cells_name, -1);
1521	if (rc)
1522		return rc;
1523
1524	while ((rc = of_phandle_iterator_next(&it)) == 0)
1525		cur_index += 1;
1526
1527	if (rc != -ENOENT)
1528		return rc;
1529
1530	return cur_index;
1531}
1532EXPORT_SYMBOL(of_count_phandle_with_args);
1533
1534static struct property *__of_remove_property_from_list(struct property **list, struct property *prop)
1535{
1536	struct property **next;
 
1537
1538	for (next = list; *next; next = &(*next)->next) {
1539		if (*next == prop) {
1540			*next = prop->next;
1541			prop->next = NULL;
1542			return prop;
1543		}
1544	}
1545	return NULL;
1546}
 
1547
1548/**
1549 * __of_add_property - Add a property to a node without lock operations
1550 * @np:		Caller's Device Node
1551 * @prop:	Property to add
1552 */
1553int __of_add_property(struct device_node *np, struct property *prop)
1554{
1555	int rc = 0;
1556	unsigned long flags;
1557	struct property **next;
1558
1559	raw_spin_lock_irqsave(&devtree_lock, flags);
1560
1561	__of_remove_property_from_list(&np->deadprops, prop);
1562
1563	prop->next = NULL;
 
1564	next = &np->properties;
1565	while (*next) {
1566		if (strcmp(prop->name, (*next)->name) == 0) {
1567			/* duplicate ! don't insert it */
1568			rc = -EEXIST;
1569			goto out_unlock;
1570		}
1571		next = &(*next)->next;
1572	}
1573	*next = prop;
 
1574
1575out_unlock:
1576	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1577	if (rc)
1578		return rc;
 
1579
1580	__of_add_property_sysfs(np, prop);
1581	return 0;
1582}
1583
1584/**
1585 * of_add_property - Add a property to a node
1586 * @np:		Caller's Device Node
1587 * @prop:	Property to add
1588 */
1589int of_add_property(struct device_node *np, struct property *prop)
1590{
1591	int rc;
1592
1593	mutex_lock(&of_mutex);
1594	rc = __of_add_property(np, prop);
1595	mutex_unlock(&of_mutex);
1596
1597	if (!rc)
1598		of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL);
1599
1600	return rc;
1601}
1602EXPORT_SYMBOL_GPL(of_add_property);
1603
1604int __of_remove_property(struct device_node *np, struct property *prop)
1605{
1606	unsigned long flags;
1607	int rc = -ENODEV;
1608
1609	raw_spin_lock_irqsave(&devtree_lock, flags);
1610
1611	if (__of_remove_property_from_list(&np->properties, prop)) {
1612		/* Found the property, add it to deadprops list */
1613		prop->next = np->deadprops;
1614		np->deadprops = prop;
1615		rc = 0;
1616	}
1617
1618	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1619	if (rc)
1620		return rc;
1621
1622	__of_remove_property_sysfs(np, prop);
1623	return 0;
1624}
1625
1626/**
1627 * of_remove_property - Remove a property from a node.
1628 * @np:		Caller's Device Node
1629 * @prop:	Property to remove
1630 *
1631 * Note that we don't actually remove it, since we have given out
1632 * who-knows-how-many pointers to the data using get-property.
1633 * Instead we just move the property to the "dead properties"
1634 * list, so it won't be found any more.
1635 */
1636int of_remove_property(struct device_node *np, struct property *prop)
1637{
1638	int rc;
1639
1640	if (!prop)
1641		return -ENODEV;
1642
1643	mutex_lock(&of_mutex);
1644	rc = __of_remove_property(np, prop);
1645	mutex_unlock(&of_mutex);
1646
1647	if (!rc)
1648		of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL);
1649
1650	return rc;
1651}
1652EXPORT_SYMBOL_GPL(of_remove_property);
1653
1654int __of_update_property(struct device_node *np, struct property *newprop,
1655		struct property **oldpropp)
1656{
1657	struct property **next, *oldprop;
1658	unsigned long flags;
 
1659
1660	raw_spin_lock_irqsave(&devtree_lock, flags);
1661
1662	__of_remove_property_from_list(&np->deadprops, newprop);
1663
1664	for (next = &np->properties; *next; next = &(*next)->next) {
1665		if (of_prop_cmp((*next)->name, newprop->name) == 0)
 
 
 
1666			break;
 
 
1667	}
1668	*oldpropp = oldprop = *next;
1669
1670	if (oldprop) {
1671		/* replace the node */
1672		newprop->next = oldprop->next;
1673		*next = newprop;
1674		oldprop->next = np->deadprops;
1675		np->deadprops = oldprop;
1676	} else {
1677		/* new node */
1678		newprop->next = NULL;
1679		*next = newprop;
1680	}
1681
1682	raw_spin_unlock_irqrestore(&devtree_lock, flags);
 
1683
1684	__of_update_property_sysfs(np, newprop, oldprop);
 
 
 
 
1685
1686	return 0;
1687}
1688
1689/*
1690 * of_update_property - Update a property in a node, if the property does
1691 * not exist, add it.
1692 *
1693 * Note that we don't actually remove it, since we have given out
1694 * who-knows-how-many pointers to the data using get-property.
1695 * Instead we just move the property to the "dead properties" list,
1696 * and add the new property to the property list
1697 */
1698int of_update_property(struct device_node *np, struct property *newprop)
1699{
1700	struct property *oldprop;
1701	int rc;
1702
1703	if (!newprop->name)
1704		return -EINVAL;
1705
1706	mutex_lock(&of_mutex);
1707	rc = __of_update_property(np, newprop, &oldprop);
1708	mutex_unlock(&of_mutex);
1709
1710	if (!rc)
1711		of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop);
1712
1713	return rc;
1714}
1715
1716static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1717			 int id, const char *stem, int stem_len)
1718{
1719	ap->np = np;
1720	ap->id = id;
1721	strscpy(ap->stem, stem, stem_len + 1);
1722	list_add_tail(&ap->link, &aliases_lookup);
1723	pr_debug("adding DT alias:%s: stem=%s id=%i node=%pOF\n",
1724		 ap->alias, ap->stem, ap->id, np);
1725}
1726
1727/**
1728 * of_alias_scan - Scan all properties of the 'aliases' node
1729 * @dt_alloc:	An allocator that provides a virtual address to memory
1730 *		for storing the resulting tree
1731 *
1732 * The function scans all the properties of the 'aliases' node and populates
1733 * the global lookup table with the properties.  It returns the
1734 * number of alias properties found, or an error code in case of failure.
1735 */
1736void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1737{
1738	struct property *pp;
1739
1740	of_aliases = of_find_node_by_path("/aliases");
1741	of_chosen = of_find_node_by_path("/chosen");
1742	if (of_chosen == NULL)
1743		of_chosen = of_find_node_by_path("/chosen@0");
1744
1745	if (of_chosen) {
1746		/* linux,stdout-path and /aliases/stdout are for legacy compatibility */
1747		const char *name = NULL;
1748
1749		if (of_property_read_string(of_chosen, "stdout-path", &name))
1750			of_property_read_string(of_chosen, "linux,stdout-path",
1751						&name);
1752		if (IS_ENABLED(CONFIG_PPC) && !name)
1753			of_property_read_string(of_aliases, "stdout", &name);
1754		if (name)
1755			of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
1756		if (of_stdout)
1757			of_stdout->fwnode.flags |= FWNODE_FLAG_BEST_EFFORT;
1758	}
1759
1760	if (!of_aliases)
1761		return;
1762
1763	for_each_property_of_node(of_aliases, pp) {
1764		const char *start = pp->name;
1765		const char *end = start + strlen(start);
1766		struct device_node *np;
1767		struct alias_prop *ap;
1768		int id, len;
1769
1770		/* Skip those we do not want to proceed */
1771		if (!strcmp(pp->name, "name") ||
1772		    !strcmp(pp->name, "phandle") ||
1773		    !strcmp(pp->name, "linux,phandle"))
1774			continue;
1775
1776		np = of_find_node_by_path(pp->value);
1777		if (!np)
1778			continue;
1779
1780		/* walk the alias backwards to extract the id and work out
1781		 * the 'stem' string */
1782		while (isdigit(*(end-1)) && end > start)
1783			end--;
1784		len = end - start;
1785
1786		if (kstrtoint(end, 10, &id) < 0)
1787			continue;
1788
1789		/* Allocate an alias_prop with enough space for the stem */
1790		ap = dt_alloc(sizeof(*ap) + len + 1, __alignof__(*ap));
1791		if (!ap)
1792			continue;
1793		memset(ap, 0, sizeof(*ap) + len + 1);
1794		ap->alias = start;
1795		of_alias_add(ap, np, id, start, len);
1796	}
1797}
1798
1799/**
1800 * of_alias_get_id - Get alias id for the given device_node
1801 * @np:		Pointer to the given device_node
1802 * @stem:	Alias stem of the given device_node
1803 *
1804 * The function travels the lookup table to get the alias id for the given
1805 * device_node and alias stem.
1806 *
1807 * Return: The alias id if found.
1808 */
1809int of_alias_get_id(struct device_node *np, const char *stem)
1810{
1811	struct alias_prop *app;
1812	int id = -ENODEV;
1813
1814	mutex_lock(&of_mutex);
1815	list_for_each_entry(app, &aliases_lookup, link) {
1816		if (strcmp(app->stem, stem) != 0)
1817			continue;
1818
1819		if (np == app->np) {
1820			id = app->id;
 
 
 
 
 
 
 
 
1821			break;
1822		}
 
1823	}
1824	mutex_unlock(&of_mutex);
1825
1826	return id;
1827}
1828EXPORT_SYMBOL_GPL(of_alias_get_id);
1829
1830/**
1831 * of_alias_get_highest_id - Get highest alias id for the given stem
1832 * @stem:	Alias stem to be examined
1833 *
1834 * The function travels the lookup table to get the highest alias id for the
1835 * given alias stem.  It returns the alias id if found.
1836 */
1837int of_alias_get_highest_id(const char *stem)
1838{
1839	struct alias_prop *app;
1840	int id = -ENODEV;
1841
1842	mutex_lock(&of_mutex);
1843	list_for_each_entry(app, &aliases_lookup, link) {
1844		if (strcmp(app->stem, stem) != 0)
1845			continue;
1846
1847		if (app->id > id)
1848			id = app->id;
1849	}
1850	mutex_unlock(&of_mutex);
 
1851
1852	return id;
1853}
1854EXPORT_SYMBOL_GPL(of_alias_get_highest_id);
1855
1856/**
1857 * of_console_check() - Test and setup console for DT setup
1858 * @dn: Pointer to device node
1859 * @name: Name to use for preferred console without index. ex. "ttyS"
1860 * @index: Index to use for preferred console.
1861 *
1862 * Check if the given device node matches the stdout-path property in the
1863 * /chosen node. If it does then register it as the preferred console.
1864 *
1865 * Return: TRUE if console successfully setup. Otherwise return FALSE.
 
 
1866 */
1867bool of_console_check(struct device_node *dn, char *name, int index)
1868{
1869	if (!dn || dn != of_stdout || console_set_on_cmdline)
1870		return false;
1871
1872	/*
1873	 * XXX: cast `options' to char pointer to suppress complication
1874	 * warnings: printk, UART and console drivers expect char pointer.
1875	 */
1876	return !add_preferred_console(name, index, (char *)of_stdout_options);
1877}
1878EXPORT_SYMBOL_GPL(of_console_check);
1879
1880/**
1881 * of_find_next_cache_node - Find a node's subsidiary cache
1882 * @np:	node of type "cpu" or "cache"
1883 *
1884 * Return: A node pointer with refcount incremented, use
1885 * of_node_put() on it when done.  Caller should hold a reference
1886 * to np.
1887 */
1888struct device_node *of_find_next_cache_node(const struct device_node *np)
1889{
1890	struct device_node *child, *cache_node;
1891
1892	cache_node = of_parse_phandle(np, "l2-cache", 0);
1893	if (!cache_node)
1894		cache_node = of_parse_phandle(np, "next-level-cache", 0);
1895
1896	if (cache_node)
1897		return cache_node;
1898
1899	/* OF on pmac has nodes instead of properties named "l2-cache"
1900	 * beneath CPU nodes.
1901	 */
1902	if (IS_ENABLED(CONFIG_PPC_PMAC) && of_node_is_type(np, "cpu"))
1903		for_each_child_of_node(np, child)
1904			if (of_node_is_type(child, "cache"))
1905				return child;
1906
1907	return NULL;
1908}
1909
1910/**
1911 * of_find_last_cache_level - Find the level at which the last cache is
1912 * 		present for the given logical cpu
1913 *
1914 * @cpu: cpu number(logical index) for which the last cache level is needed
1915 *
1916 * Return: The level at which the last cache is present. It is exactly
1917 * same as  the total number of cache levels for the given logical cpu.
1918 */
1919int of_find_last_cache_level(unsigned int cpu)
1920{
1921	u32 cache_level = 0;
1922	struct device_node *prev = NULL, *np = of_cpu_device_node_get(cpu);
1923
1924	while (np) {
1925		of_node_put(prev);
1926		prev = np;
1927		np = of_find_next_cache_node(np);
1928	}
1929
1930	of_property_read_u32(prev, "cache-level", &cache_level);
1931	of_node_put(prev);
1932
1933	return cache_level;
 
 
 
 
 
1934}
1935
1936/**
1937 * of_map_id - Translate an ID through a downstream mapping.
1938 * @np: root complex device node.
1939 * @id: device ID to map.
1940 * @map_name: property name of the map to use.
1941 * @map_mask_name: optional property name of the mask to use.
1942 * @target: optional pointer to a target device node.
1943 * @id_out: optional pointer to receive the translated ID.
1944 *
1945 * Given a device ID, look up the appropriate implementation-defined
1946 * platform ID and/or the target device which receives transactions on that
1947 * ID, as per the "iommu-map" and "msi-map" bindings. Either of @target or
1948 * @id_out may be NULL if only the other is required. If @target points to
1949 * a non-NULL device node pointer, only entries targeting that node will be
1950 * matched; if it points to a NULL value, it will receive the device node of
1951 * the first matching target phandle, with a reference held.
1952 *
1953 * Return: 0 on success or a standard error code on failure.
1954 */
1955int of_map_id(struct device_node *np, u32 id,
1956	       const char *map_name, const char *map_mask_name,
1957	       struct device_node **target, u32 *id_out)
1958{
1959	u32 map_mask, masked_id;
1960	int map_len;
1961	const __be32 *map = NULL;
1962
1963	if (!np || !map_name || (!target && !id_out))
1964		return -EINVAL;
1965
1966	map = of_get_property(np, map_name, &map_len);
1967	if (!map) {
1968		if (target)
1969			return -ENODEV;
1970		/* Otherwise, no map implies no translation */
1971		*id_out = id;
1972		return 0;
1973	}
1974
1975	if (!map_len || map_len % (4 * sizeof(*map))) {
1976		pr_err("%pOF: Error: Bad %s length: %d\n", np,
1977			map_name, map_len);
1978		return -EINVAL;
1979	}
1980
1981	/* The default is to select all bits. */
1982	map_mask = 0xffffffff;
1983
1984	/*
1985	 * Can be overridden by "{iommu,msi}-map-mask" property.
1986	 * If of_property_read_u32() fails, the default is used.
1987	 */
1988	if (map_mask_name)
1989		of_property_read_u32(np, map_mask_name, &map_mask);
1990
1991	masked_id = map_mask & id;
1992	for ( ; map_len > 0; map_len -= 4 * sizeof(*map), map += 4) {
1993		struct device_node *phandle_node;
1994		u32 id_base = be32_to_cpup(map + 0);
1995		u32 phandle = be32_to_cpup(map + 1);
1996		u32 out_base = be32_to_cpup(map + 2);
1997		u32 id_len = be32_to_cpup(map + 3);
1998
1999		if (id_base & ~map_mask) {
2000			pr_err("%pOF: Invalid %s translation - %s-mask (0x%x) ignores id-base (0x%x)\n",
2001				np, map_name, map_name,
2002				map_mask, id_base);
2003			return -EFAULT;
2004		}
2005
2006		if (masked_id < id_base || masked_id >= id_base + id_len)
2007			continue;
2008
2009		phandle_node = of_find_node_by_phandle(phandle);
2010		if (!phandle_node)
2011			return -ENODEV;
2012
2013		if (target) {
2014			if (*target)
2015				of_node_put(phandle_node);
2016			else
2017				*target = phandle_node;
2018
2019			if (*target != phandle_node)
2020				continue;
2021		}
2022
2023		if (id_out)
2024			*id_out = masked_id - id_base + out_base;
2025
2026		pr_debug("%pOF: %s, using mask %08x, id-base: %08x, out-base: %08x, length: %08x, id: %08x -> %08x\n",
2027			np, map_name, map_mask, id_base, out_base,
2028			id_len, id, masked_id - id_base + out_base);
2029		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2030	}
2031
2032	pr_info("%pOF: no %s translation for id 0x%x on %pOF\n", np, map_name,
2033		id, target && *target ? *target : NULL);
2034
2035	/* Bypasses translation */
2036	if (id_out)
2037		*id_out = id;
2038	return 0;
2039}
2040EXPORT_SYMBOL_GPL(of_map_id);