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