unittest.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Self tests for device tree subsystem
   4 */
   5
   6#define pr_fmt(fmt) "### dt-test ### " fmt
   7
   8#include <linux/memblock.h>
   9#include <linux/clk.h>
  10#include <linux/dma-direct.h> /* to test phys_to_dma/dma_to_phys */
  11#include <linux/err.h>
  12#include <linux/errno.h>
  13#include <linux/hashtable.h>
  14#include <linux/libfdt.h>
  15#include <linux/of.h>
  16#include <linux/of_address.h>
  17#include <linux/of_fdt.h>
  18#include <linux/of_irq.h>
  19#include <linux/of_platform.h>
  20#include <linux/list.h>
  21#include <linux/mutex.h>
  22#include <linux/slab.h>
  23#include <linux/device.h>
  24#include <linux/platform_device.h>
  25#include <linux/pci.h>
  26#include <linux/kernel.h>
  27
  28#include <linux/i2c.h>
  29#include <linux/i2c-mux.h>
  30#include <linux/gpio/driver.h>
  31
  32#include <linux/bitops.h>
  33
  34#include "of_private.h"
  35
  36static struct unittest_results {
  37	int passed;
  38	int failed;
  39} unittest_results;
  40
  41#define unittest(result, fmt, ...) ({ \
  42	bool failed = !(result); \
  43	if (failed) { \
  44		unittest_results.failed++; \
  45		pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
  46	} else { \
  47		unittest_results.passed++; \
  48		pr_info("pass %s():%i\n", __func__, __LINE__); \
  49	} \
  50	failed; \
  51})
  52
  53#ifdef CONFIG_OF_KOBJ
  54#define OF_KREF_READ(NODE) kref_read(&(NODE)->kobj.kref)
  55#else
  56#define OF_KREF_READ(NODE) 1
  57#endif
  58
  59/*
  60 * Expected message may have a message level other than KERN_INFO.
  61 * Print the expected message only if the current loglevel will allow
  62 * the actual message to print.
  63 *
  64 * Do not use EXPECT_BEGIN(), EXPECT_END(), EXPECT_NOT_BEGIN(), or
  65 * EXPECT_NOT_END() to report messages expected to be reported or not
  66 * reported by pr_debug().
  67 */
  68#define EXPECT_BEGIN(level, fmt, ...) \
  69	printk(level pr_fmt("EXPECT \\ : ") fmt, ##__VA_ARGS__)
  70
  71#define EXPECT_END(level, fmt, ...) \
  72	printk(level pr_fmt("EXPECT / : ") fmt, ##__VA_ARGS__)
  73
  74#define EXPECT_NOT_BEGIN(level, fmt, ...) \
  75	printk(level pr_fmt("EXPECT_NOT \\ : ") fmt, ##__VA_ARGS__)
  76
  77#define EXPECT_NOT_END(level, fmt, ...) \
  78	printk(level pr_fmt("EXPECT_NOT / : ") fmt, ##__VA_ARGS__)
  79
  80static void __init of_unittest_find_node_by_name(void)
  81{
  82	struct device_node *np;
  83	const char *options, *name;
  84
  85	np = of_find_node_by_path("/testcase-data");
  86	name = kasprintf(GFP_KERNEL, "%pOF", np);
  87	unittest(np && name && !strcmp("/testcase-data", name),
  88		"find /testcase-data failed\n");
  89	of_node_put(np);
  90	kfree(name);
  91
  92	/* Test if trailing '/' works */
  93	np = of_find_node_by_path("/testcase-data/");
  94	unittest(!np, "trailing '/' on /testcase-data/ should fail\n");
  95
  96	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
  97	name = kasprintf(GFP_KERNEL, "%pOF", np);
  98	unittest(np && name && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
  99		"find /testcase-data/phandle-tests/consumer-a failed\n");
 100	of_node_put(np);
 101	kfree(name);
 102
 103	np = of_find_node_by_path("testcase-alias");
 104	name = kasprintf(GFP_KERNEL, "%pOF", np);
 105	unittest(np && name && !strcmp("/testcase-data", name),
 106		"find testcase-alias failed\n");
 107	of_node_put(np);
 108	kfree(name);
 109
 110	/* Test if trailing '/' works on aliases */
 111	np = of_find_node_by_path("testcase-alias/");
 112	unittest(!np, "trailing '/' on testcase-alias/ should fail\n");
 113
 114	np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
 115	name = kasprintf(GFP_KERNEL, "%pOF", np);
 116	unittest(np && name && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
 117		"find testcase-alias/phandle-tests/consumer-a failed\n");
 118	of_node_put(np);
 119	kfree(name);
 120
 121	np = of_find_node_by_path("/testcase-data/missing-path");
 122	unittest(!np, "non-existent path returned node %pOF\n", np);
 123	of_node_put(np);
 124
 125	np = of_find_node_by_path("missing-alias");
 126	unittest(!np, "non-existent alias returned node %pOF\n", np);
 127	of_node_put(np);
 128
 129	np = of_find_node_by_path("testcase-alias/missing-path");
 130	unittest(!np, "non-existent alias with relative path returned node %pOF\n", np);
 131	of_node_put(np);
 132
 133	np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
 134	unittest(np && !strcmp("testoption", options),
 135		 "option path test failed\n");
 136	of_node_put(np);
 137
 138	np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
 139	unittest(np && !strcmp("test/option", options),
 140		 "option path test, subcase #1 failed\n");
 141	of_node_put(np);
 142
 143	np = of_find_node_opts_by_path("/testcase-data/testcase-device1:test/option", &options);
 144	unittest(np && !strcmp("test/option", options),
 145		 "option path test, subcase #2 failed\n");
 146	of_node_put(np);
 147
 148	np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
 149	unittest(np, "NULL option path test failed\n");
 150	of_node_put(np);
 151
 152	np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
 153				       &options);
 154	unittest(np && !strcmp("testaliasoption", options),
 155		 "option alias path test failed\n");
 156	of_node_put(np);
 157
 158	np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
 159				       &options);
 160	unittest(np && !strcmp("test/alias/option", options),
 161		 "option alias path test, subcase #1 failed\n");
 162	of_node_put(np);
 163
 164	np = of_find_node_opts_by_path("testcase-alias/phandle-tests/consumer-a:testaliasoption",
 165				       &options);
 166	name = kasprintf(GFP_KERNEL, "%pOF", np);
 167	unittest(np && name && !strcmp("/testcase-data/phandle-tests/consumer-a", name) &&
 168		 !strcmp("testaliasoption", options),
 169		 "option alias path test, subcase #2 failed\n");
 170	of_node_put(np);
 171	kfree(name);
 172
 173	np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
 174	unittest(np, "NULL option alias path test failed\n");
 175	of_node_put(np);
 176
 177	options = "testoption";
 178	np = of_find_node_opts_by_path("testcase-alias", &options);
 179	unittest(np && !options, "option clearing test failed\n");
 180	of_node_put(np);
 181
 182	options = "testoption";
 183	np = of_find_node_opts_by_path("/", &options);
 184	unittest(np && !options, "option clearing root node test failed\n");
 185	of_node_put(np);
 186}
 187
 188static void __init of_unittest_dynamic(void)
 189{
 190	struct device_node *np;
 191	struct property *prop;
 192
 193	np = of_find_node_by_path("/testcase-data");
 194	if (!np) {
 195		pr_err("missing testcase data\n");
 196		return;
 197	}
 198
 199	/* Array of 4 properties for the purpose of testing */
 200	prop = kcalloc(4, sizeof(*prop), GFP_KERNEL);
 201	if (!prop) {
 202		unittest(0, "kzalloc() failed\n");
 203		return;
 204	}
 205
 206	/* Add a new property - should pass*/
 207	prop->name = "new-property";
 208	prop->value = "new-property-data";
 209	prop->length = strlen(prop->value) + 1;
 210	unittest(of_add_property(np, prop) == 0, "Adding a new property failed\n");
 211
 212	/* Try to add an existing property - should fail */
 213	prop++;
 214	prop->name = "new-property";
 215	prop->value = "new-property-data-should-fail";
 216	prop->length = strlen(prop->value) + 1;
 217	unittest(of_add_property(np, prop) != 0,
 218		 "Adding an existing property should have failed\n");
 219
 220	/* Try to modify an existing property - should pass */
 221	prop->value = "modify-property-data-should-pass";
 222	prop->length = strlen(prop->value) + 1;
 223	unittest(of_update_property(np, prop) == 0,
 224		 "Updating an existing property should have passed\n");
 225
 226	/* Try to modify non-existent property - should pass*/
 227	prop++;
 228	prop->name = "modify-property";
 229	prop->value = "modify-missing-property-data-should-pass";
 230	prop->length = strlen(prop->value) + 1;
 231	unittest(of_update_property(np, prop) == 0,
 232		 "Updating a missing property should have passed\n");
 233
 234	/* Remove property - should pass */
 235	unittest(of_remove_property(np, prop) == 0,
 236		 "Removing a property should have passed\n");
 237
 238	/* Adding very large property - should pass */
 239	prop++;
 240	prop->name = "large-property-PAGE_SIZEx8";
 241	prop->length = PAGE_SIZE * 8;
 242	prop->value = kzalloc(prop->length, GFP_KERNEL);
 243	unittest(prop->value != NULL, "Unable to allocate large buffer\n");
 244	if (prop->value)
 245		unittest(of_add_property(np, prop) == 0,
 246			 "Adding a large property should have passed\n");
 247}
 248
 249static int __init of_unittest_check_node_linkage(struct device_node *np)
 250{
 251	int count = 0, rc;
 252
 253	for_each_child_of_node_scoped(np, child) {
 254		if (child->parent != np) {
 255			pr_err("Child node %pOFn links to wrong parent %pOFn\n",
 256				 child, np);
 257			return -EINVAL;
 258		}
 259
 260		rc = of_unittest_check_node_linkage(child);
 261		if (rc < 0)
 262			return rc;
 263		count += rc;
 264	}
 265
 266	return count + 1;
 267}
 268
 269static void __init of_unittest_check_tree_linkage(void)
 270{
 271	struct device_node *np;
 272	int allnode_count = 0, child_count;
 273
 274	if (!of_root)
 275		return;
 276
 277	for_each_of_allnodes(np)
 278		allnode_count++;
 279	child_count = of_unittest_check_node_linkage(of_root);
 280
 281	unittest(child_count > 0, "Device node data structure is corrupted\n");
 282	unittest(child_count == allnode_count,
 283		 "allnodes list size (%i) doesn't match sibling lists size (%i)\n",
 284		 allnode_count, child_count);
 285	pr_debug("allnodes list size (%i); sibling lists size (%i)\n", allnode_count, child_count);
 286}
 287
 288static void __init of_unittest_printf_one(struct device_node *np, const char *fmt,
 289					  const char *expected)
 290{
 291	unsigned char *buf;
 292	int buf_size;
 293	int size, i;
 294
 295	buf_size = strlen(expected) + 10;
 296	buf = kmalloc(buf_size, GFP_KERNEL);
 297	if (!buf)
 298		return;
 299
 300	/* Baseline; check conversion with a large size limit */
 301	memset(buf, 0xff, buf_size);
 302	size = snprintf(buf, buf_size - 2, fmt, np);
 303
 304	/* use strcmp() instead of strncmp() here to be absolutely sure strings match */
 305	unittest((strcmp(buf, expected) == 0) && (buf[size+1] == 0xff),
 306		"sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
 307		fmt, expected, buf);
 308
 309	/* Make sure length limits work */
 310	size++;
 311	for (i = 0; i < 2; i++, size--) {
 312		/* Clear the buffer, and make sure it works correctly still */
 313		memset(buf, 0xff, buf_size);
 314		snprintf(buf, size+1, fmt, np);
 315		unittest(strncmp(buf, expected, size) == 0 && (buf[size+1] == 0xff),
 316			"snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
 317			size, fmt, expected, buf);
 318	}
 319	kfree(buf);
 320}
 321
 322static void __init of_unittest_printf(void)
 323{
 324	struct device_node *np;
 325	const char *full_name = "/testcase-data/platform-tests/test-device@1/dev@100";
 326	char phandle_str[16] = "";
 327
 328	np = of_find_node_by_path(full_name);
 329	if (!np) {
 330		unittest(np, "testcase data missing\n");
 331		return;
 332	}
 333
 334	num_to_str(phandle_str, sizeof(phandle_str), np->phandle, 0);
 335
 336	of_unittest_printf_one(np, "%pOF",  full_name);
 337	of_unittest_printf_one(np, "%pOFf", full_name);
 338	of_unittest_printf_one(np, "%pOFn", "dev");
 339	of_unittest_printf_one(np, "%2pOFn", "dev");
 340	of_unittest_printf_one(np, "%5pOFn", "  dev");
 341	of_unittest_printf_one(np, "%pOFnc", "dev:test-sub-device");
 342	of_unittest_printf_one(np, "%pOFp", phandle_str);
 343	of_unittest_printf_one(np, "%pOFP", "dev@100");
 344	of_unittest_printf_one(np, "ABC %pOFP ABC", "ABC dev@100 ABC");
 345	of_unittest_printf_one(np, "%10pOFP", "   dev@100");
 346	of_unittest_printf_one(np, "%-10pOFP", "dev@100   ");
 347	of_unittest_printf_one(of_root, "%pOFP", "/");
 348	of_unittest_printf_one(np, "%pOFF", "----");
 349	of_unittest_printf_one(np, "%pOFPF", "dev@100:----");
 350	of_unittest_printf_one(np, "%pOFPFPc", "dev@100:----:dev@100:test-sub-device");
 351	of_unittest_printf_one(np, "%pOFc", "test-sub-device");
 352	of_unittest_printf_one(np, "%pOFC",
 353			"\"test-sub-device\",\"test-compat2\",\"test-compat3\"");
 354}
 355
 356struct node_hash {
 357	struct hlist_node node;
 358	struct device_node *np;
 359};
 360
 361static DEFINE_HASHTABLE(phandle_ht, 8);
 362static void __init of_unittest_check_phandles(void)
 363{
 364	struct device_node *np;
 365	struct node_hash *nh;
 366	struct hlist_node *tmp;
 367	int i, dup_count = 0, phandle_count = 0;
 368
 369	for_each_of_allnodes(np) {
 370		if (!np->phandle)
 371			continue;
 372
 373		hash_for_each_possible(phandle_ht, nh, node, np->phandle) {
 374			if (nh->np->phandle == np->phandle) {
 375				pr_info("Duplicate phandle! %i used by %pOF and %pOF\n",
 376					np->phandle, nh->np, np);
 377				dup_count++;
 378				break;
 379			}
 380		}
 381
 382		nh = kzalloc(sizeof(*nh), GFP_KERNEL);
 383		if (!nh)
 384			return;
 385
 386		nh->np = np;
 387		hash_add(phandle_ht, &nh->node, np->phandle);
 388		phandle_count++;
 389	}
 390	unittest(dup_count == 0, "Found %i duplicates in %i phandles\n",
 391		 dup_count, phandle_count);
 392
 393	/* Clean up */
 394	hash_for_each_safe(phandle_ht, i, tmp, nh, node) {
 395		hash_del(&nh->node);
 396		kfree(nh);
 397	}
 398}
 399
 400static void __init of_unittest_parse_phandle_with_args(void)
 401{
 402	struct device_node *np;
 403	struct of_phandle_args args;
 404	int i, rc;
 405
 406	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
 407	if (!np) {
 408		pr_err("missing testcase data\n");
 409		return;
 410	}
 411
 412	rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
 413	unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
 414
 415	for (i = 0; i < 8; i++) {
 416		bool passed = true;
 417
 418		memset(&args, 0, sizeof(args));
 419		rc = of_parse_phandle_with_args(np, "phandle-list",
 420						"#phandle-cells", i, &args);
 421
 422		/* Test the values from tests-phandle.dtsi */
 423		switch (i) {
 424		case 0:
 425			passed &= !rc;
 426			passed &= (args.args_count == 1);
 427			passed &= (args.args[0] == (i + 1));
 428			break;
 429		case 1:
 430			passed &= !rc;
 431			passed &= (args.args_count == 2);
 432			passed &= (args.args[0] == (i + 1));
 433			passed &= (args.args[1] == 0);
 434			break;
 435		case 2:
 436			passed &= (rc == -ENOENT);
 437			break;
 438		case 3:
 439			passed &= !rc;
 440			passed &= (args.args_count == 3);
 441			passed &= (args.args[0] == (i + 1));
 442			passed &= (args.args[1] == 4);
 443			passed &= (args.args[2] == 3);
 444			break;
 445		case 4:
 446			passed &= !rc;
 447			passed &= (args.args_count == 2);
 448			passed &= (args.args[0] == (i + 1));
 449			passed &= (args.args[1] == 100);
 450			break;
 451		case 5:
 452			passed &= !rc;
 453			passed &= (args.args_count == 0);
 454			break;
 455		case 6:
 456			passed &= !rc;
 457			passed &= (args.args_count == 1);
 458			passed &= (args.args[0] == (i + 1));
 459			break;
 460		case 7:
 461			passed &= (rc == -ENOENT);
 462			break;
 463		default:
 464			passed = false;
 465		}
 466
 467		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
 468			 i, args.np, rc);
 469
 470		if (rc == 0)
 471			of_node_put(args.np);
 472	}
 473
 474	/* Check for missing list property */
 475	memset(&args, 0, sizeof(args));
 476	rc = of_parse_phandle_with_args(np, "phandle-list-missing",
 477					"#phandle-cells", 0, &args);
 478	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 479	rc = of_count_phandle_with_args(np, "phandle-list-missing",
 480					"#phandle-cells");
 481	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 482
 483	/* Check for missing cells property */
 484	memset(&args, 0, sizeof(args));
 485
 486	EXPECT_BEGIN(KERN_INFO,
 487		     "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 488
 489	rc = of_parse_phandle_with_args(np, "phandle-list",
 490					"#phandle-cells-missing", 0, &args);
 491
 492	EXPECT_END(KERN_INFO,
 493		   "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 494
 495	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 496
 497	EXPECT_BEGIN(KERN_INFO,
 498		     "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 499
 500	rc = of_count_phandle_with_args(np, "phandle-list",
 501					"#phandle-cells-missing");
 502
 503	EXPECT_END(KERN_INFO,
 504		   "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 505
 506	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 507
 508	/* Check for bad phandle in list */
 509	memset(&args, 0, sizeof(args));
 510
 511	EXPECT_BEGIN(KERN_INFO,
 512		     "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 513
 514	rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle",
 515					"#phandle-cells", 0, &args);
 516
 517	EXPECT_END(KERN_INFO,
 518		   "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 519
 520	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 521
 522	EXPECT_BEGIN(KERN_INFO,
 523		     "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 524
 525	rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle",
 526					"#phandle-cells");
 527
 528	EXPECT_END(KERN_INFO,
 529		   "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 530
 531	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 532
 533	/* Check for incorrectly formed argument list */
 534	memset(&args, 0, sizeof(args));
 535
 536	EXPECT_BEGIN(KERN_INFO,
 537		     "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
 538
 539	rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
 540					"#phandle-cells", 1, &args);
 541
 542	EXPECT_END(KERN_INFO,
 543		   "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
 544
 545	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 546
 547	EXPECT_BEGIN(KERN_INFO,
 548		     "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
 549
 550	rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
 551					"#phandle-cells");
 552
 553	EXPECT_END(KERN_INFO,
 554		   "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found 1");
 555
 556	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 557}
 558
 559static void __init of_unittest_parse_phandle_with_args_map(void)
 560{
 561	struct device_node *np, *p[6] = {};
 562	struct of_phandle_args args;
 563	unsigned int prefs[6];
 564	int i, rc;
 565
 566	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-b");
 567	if (!np) {
 568		pr_err("missing testcase data\n");
 569		return;
 570	}
 571
 572	p[0] = of_find_node_by_path("/testcase-data/phandle-tests/provider0");
 573	p[1] = of_find_node_by_path("/testcase-data/phandle-tests/provider1");
 574	p[2] = of_find_node_by_path("/testcase-data/phandle-tests/provider2");
 575	p[3] = of_find_node_by_path("/testcase-data/phandle-tests/provider3");
 576	p[4] = of_find_node_by_path("/testcase-data/phandle-tests/provider4");
 577	p[5] = of_find_node_by_path("/testcase-data/phandle-tests/provider5");
 578	for (i = 0; i < ARRAY_SIZE(p); ++i) {
 579		if (!p[i]) {
 580			pr_err("missing testcase data\n");
 581			return;
 582		}
 583		prefs[i] = OF_KREF_READ(p[i]);
 584	}
 585
 586	rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
 587	unittest(rc == 8, "of_count_phandle_with_args() returned %i, expected 8\n", rc);
 588
 589	for (i = 0; i < 9; i++) {
 590		bool passed = true;
 591
 592		memset(&args, 0, sizeof(args));
 593		rc = of_parse_phandle_with_args_map(np, "phandle-list",
 594						    "phandle", i, &args);
 595
 596		/* Test the values from tests-phandle.dtsi */
 597		switch (i) {
 598		case 0:
 599			passed &= !rc;
 600			passed &= (args.np == p[1]);
 601			passed &= (args.args_count == 1);
 602			passed &= (args.args[0] == 1);
 603			break;
 604		case 1:
 605			passed &= !rc;
 606			passed &= (args.np == p[3]);
 607			passed &= (args.args_count == 3);
 608			passed &= (args.args[0] == 2);
 609			passed &= (args.args[1] == 5);
 610			passed &= (args.args[2] == 3);
 611			break;
 612		case 2:
 613			passed &= (rc == -ENOENT);
 614			break;
 615		case 3:
 616			passed &= !rc;
 617			passed &= (args.np == p[0]);
 618			passed &= (args.args_count == 0);
 619			break;
 620		case 4:
 621			passed &= !rc;
 622			passed &= (args.np == p[1]);
 623			passed &= (args.args_count == 1);
 624			passed &= (args.args[0] == 3);
 625			break;
 626		case 5:
 627			passed &= !rc;
 628			passed &= (args.np == p[0]);
 629			passed &= (args.args_count == 0);
 630			break;
 631		case 6:
 632			passed &= !rc;
 633			passed &= (args.np == p[2]);
 634			passed &= (args.args_count == 2);
 635			passed &= (args.args[0] == 15);
 636			passed &= (args.args[1] == 0x20);
 637			break;
 638		case 7:
 639			passed &= !rc;
 640			passed &= (args.np == p[3]);
 641			passed &= (args.args_count == 3);
 642			passed &= (args.args[0] == 2);
 643			passed &= (args.args[1] == 5);
 644			passed &= (args.args[2] == 3);
 645			break;
 646		case 8:
 647			passed &= (rc == -ENOENT);
 648			break;
 649		default:
 650			passed = false;
 651		}
 652
 653		unittest(passed, "index %i - data error on node %s rc=%i\n",
 654			 i, args.np->full_name, rc);
 655
 656		if (rc == 0)
 657			of_node_put(args.np);
 658	}
 659
 660	/* Check for missing list property */
 661	memset(&args, 0, sizeof(args));
 662	rc = of_parse_phandle_with_args_map(np, "phandle-list-missing",
 663					    "phandle", 0, &args);
 664	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 665
 666	/* Check for missing cells,map,mask property */
 667	memset(&args, 0, sizeof(args));
 668
 669	EXPECT_BEGIN(KERN_INFO,
 670		     "OF: /testcase-data/phandle-tests/consumer-b: could not get #phandle-missing-cells for /testcase-data/phandle-tests/provider1");
 671
 672	rc = of_parse_phandle_with_args_map(np, "phandle-list",
 673					    "phandle-missing", 0, &args);
 674	EXPECT_END(KERN_INFO,
 675		   "OF: /testcase-data/phandle-tests/consumer-b: could not get #phandle-missing-cells for /testcase-data/phandle-tests/provider1");
 676
 677	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 678
 679	/* Check for bad phandle in list */
 680	memset(&args, 0, sizeof(args));
 681
 682	EXPECT_BEGIN(KERN_INFO,
 683		     "OF: /testcase-data/phandle-tests/consumer-b: could not find phandle 12345678");
 684
 685	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-phandle",
 686					    "phandle", 0, &args);
 687	EXPECT_END(KERN_INFO,
 688		   "OF: /testcase-data/phandle-tests/consumer-b: could not find phandle 12345678");
 689
 690	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 691
 692	/* Check for incorrectly formed argument list */
 693	memset(&args, 0, sizeof(args));
 694
 695	EXPECT_BEGIN(KERN_INFO,
 696		     "OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found 1");
 697
 698	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-args",
 699					    "phandle", 1, &args);
 700	EXPECT_END(KERN_INFO,
 701		   "OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found 1");
 702
 703	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 704
 705	for (i = 0; i < ARRAY_SIZE(p); ++i) {
 706		unittest(prefs[i] == OF_KREF_READ(p[i]),
 707			 "provider%d: expected:%d got:%d\n",
 708			 i, prefs[i], OF_KREF_READ(p[i]));
 709		of_node_put(p[i]);
 710	}
 711}
 712
 713static void __init of_unittest_property_string(void)
 714{
 715	const char *strings[4];
 716	struct device_node *np;
 717	int rc;
 718
 719	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
 720	if (!np) {
 721		pr_err("No testcase data in device tree\n");
 722		return;
 723	}
 724
 725	rc = of_property_match_string(np, "phandle-list-names", "first");
 726	unittest(rc == 0, "first expected:0 got:%i\n", rc);
 727	rc = of_property_match_string(np, "phandle-list-names", "second");
 728	unittest(rc == 1, "second expected:1 got:%i\n", rc);
 729	rc = of_property_match_string(np, "phandle-list-names", "third");
 730	unittest(rc == 2, "third expected:2 got:%i\n", rc);
 731	rc = of_property_match_string(np, "phandle-list-names", "fourth");
 732	unittest(rc == -ENODATA, "unmatched string; rc=%i\n", rc);
 733	rc = of_property_match_string(np, "missing-property", "blah");
 734	unittest(rc == -EINVAL, "missing property; rc=%i\n", rc);
 735	rc = of_property_match_string(np, "empty-property", "blah");
 736	unittest(rc == -ENODATA, "empty property; rc=%i\n", rc);
 737	rc = of_property_match_string(np, "unterminated-string", "blah");
 738	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 739
 740	/* of_property_count_strings() tests */
 741	rc = of_property_count_strings(np, "string-property");
 742	unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 743	rc = of_property_count_strings(np, "phandle-list-names");
 744	unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 745	rc = of_property_count_strings(np, "unterminated-string");
 746	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 747	rc = of_property_count_strings(np, "unterminated-string-list");
 748	unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
 749
 750	/* of_property_read_string_index() tests */
 751	rc = of_property_read_string_index(np, "string-property", 0, strings);
 752	unittest(rc == 0 && !strcmp(strings[0], "foobar"), "of_property_read_string_index() failure; rc=%i\n", rc);
 753	strings[0] = NULL;
 754	rc = of_property_read_string_index(np, "string-property", 1, strings);
 755	unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 756	rc = of_property_read_string_index(np, "phandle-list-names", 0, strings);
 757	unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
 758	rc = of_property_read_string_index(np, "phandle-list-names", 1, strings);
 759	unittest(rc == 0 && !strcmp(strings[0], "second"), "of_property_read_string_index() failure; rc=%i\n", rc);
 760	rc = of_property_read_string_index(np, "phandle-list-names", 2, strings);
 761	unittest(rc == 0 && !strcmp(strings[0], "third"), "of_property_read_string_index() failure; rc=%i\n", rc);
 762	strings[0] = NULL;
 763	rc = of_property_read_string_index(np, "phandle-list-names", 3, strings);
 764	unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 765	strings[0] = NULL;
 766	rc = of_property_read_string_index(np, "unterminated-string", 0, strings);
 767	unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 768	rc = of_property_read_string_index(np, "unterminated-string-list", 0, strings);
 769	unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
 770	strings[0] = NULL;
 771	rc = of_property_read_string_index(np, "unterminated-string-list", 2, strings); /* should fail */
 772	unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 773	strings[1] = NULL;
 774
 775	/* of_property_read_string_array() tests */
 776	rc = of_property_read_string_array(np, "string-property", strings, 4);
 777	unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 778	rc = of_property_read_string_array(np, "phandle-list-names", strings, 4);
 779	unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 780	rc = of_property_read_string_array(np, "unterminated-string", strings, 4);
 781	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 782	/* -- An incorrectly formed string should cause a failure */
 783	rc = of_property_read_string_array(np, "unterminated-string-list", strings, 4);
 784	unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
 785	/* -- parsing the correctly formed strings should still work: */
 786	strings[2] = NULL;
 787	rc = of_property_read_string_array(np, "unterminated-string-list", strings, 2);
 788	unittest(rc == 2 && strings[2] == NULL, "of_property_read_string_array() failure; rc=%i\n", rc);
 789	strings[1] = NULL;
 790	rc = of_property_read_string_array(np, "phandle-list-names", strings, 1);
 791	unittest(rc == 1 && strings[1] == NULL, "Overwrote end of string array; rc=%i, str='%s'\n", rc, strings[1]);
 792}
 793
 794#define propcmp(p1, p2) (((p1)->length == (p2)->length) && \
 795			(p1)->value && (p2)->value && \
 796			!memcmp((p1)->value, (p2)->value, (p1)->length) && \
 797			!strcmp((p1)->name, (p2)->name))
 798static void __init of_unittest_property_copy(void)
 799{
 800#ifdef CONFIG_OF_DYNAMIC
 801	struct property p1 = { .name = "p1", .length = 0, .value = "" };
 802	struct property p2 = { .name = "p2", .length = 5, .value = "abcd" };
 803	struct property *new;
 804
 805	new = __of_prop_dup(&p1, GFP_KERNEL);
 806	unittest(new && propcmp(&p1, new), "empty property didn't copy correctly\n");
 807	if (new)
 808		__of_prop_free(new);
 809
 810	new = __of_prop_dup(&p2, GFP_KERNEL);
 811	unittest(new && propcmp(&p2, new), "non-empty property didn't copy correctly\n");
 812	if (new)
 813		__of_prop_free(new);
 814#endif
 815}
 816
 817static void __init of_unittest_changeset(void)
 818{
 819#ifdef CONFIG_OF_DYNAMIC
 820	int ret;
 821	struct property *ppadd, padd = { .name = "prop-add", .length = 1, .value = "" };
 822	struct property *ppname_n1,  pname_n1  = { .name = "name", .length = 3, .value = "n1"  };
 823	struct property *ppname_n2,  pname_n2  = { .name = "name", .length = 3, .value = "n2"  };
 824	struct property *ppname_n21, pname_n21 = { .name = "name", .length = 3, .value = "n21" };
 825	struct property *ppupdate, pupdate = { .name = "prop-update", .length = 5, .value = "abcd" };
 826	struct property *ppremove;
 827	struct device_node *n1, *n2, *n21, *n22, *nchangeset, *nremove, *parent, *np;
 828	static const char * const str_array[] = { "str1", "str2", "str3" };
 829	const u32 u32_array[] = { 1, 2, 3 };
 830	struct of_changeset chgset;
 831	const char *propstr = NULL;
 832
 833	n1 = __of_node_dup(NULL, "n1");
 834	unittest(n1, "testcase setup failure\n");
 835
 836	n2 = __of_node_dup(NULL, "n2");
 837	unittest(n2, "testcase setup failure\n");
 838
 839	n21 = __of_node_dup(NULL, "n21");
 840	unittest(n21, "testcase setup failure %p\n", n21);
 841
 842	nchangeset = of_find_node_by_path("/testcase-data/changeset");
 843	nremove = of_get_child_by_name(nchangeset, "node-remove");
 844	unittest(nremove, "testcase setup failure\n");
 845
 846	ppadd = __of_prop_dup(&padd, GFP_KERNEL);
 847	unittest(ppadd, "testcase setup failure\n");
 848
 849	ppname_n1  = __of_prop_dup(&pname_n1, GFP_KERNEL);
 850	unittest(ppname_n1, "testcase setup failure\n");
 851
 852	ppname_n2  = __of_prop_dup(&pname_n2, GFP_KERNEL);
 853	unittest(ppname_n2, "testcase setup failure\n");
 854
 855	ppname_n21 = __of_prop_dup(&pname_n21, GFP_KERNEL);
 856	unittest(ppname_n21, "testcase setup failure\n");
 857
 858	ppupdate = __of_prop_dup(&pupdate, GFP_KERNEL);
 859	unittest(ppupdate, "testcase setup failure\n");
 860
 861	parent = nchangeset;
 862	n1->parent = parent;
 863	n2->parent = parent;
 864	n21->parent = n2;
 865
 866	ppremove = of_find_property(parent, "prop-remove", NULL);
 867	unittest(ppremove, "failed to find removal prop");
 868
 869	of_changeset_init(&chgset);
 870
 871	unittest(!of_changeset_attach_node(&chgset, n1), "fail attach n1\n");
 872	unittest(!of_changeset_add_property(&chgset, n1, ppname_n1), "fail add prop name\n");
 873
 874	unittest(!of_changeset_attach_node(&chgset, n2), "fail attach n2\n");
 875	unittest(!of_changeset_add_property(&chgset, n2, ppname_n2), "fail add prop name\n");
 876
 877	unittest(!of_changeset_detach_node(&chgset, nremove), "fail remove node\n");
 878	unittest(!of_changeset_add_property(&chgset, n21, ppname_n21), "fail add prop name\n");
 879
 880	unittest(!of_changeset_attach_node(&chgset, n21), "fail attach n21\n");
 881
 882	unittest(!of_changeset_add_property(&chgset, parent, ppadd), "fail add prop prop-add\n");
 883	unittest(!of_changeset_update_property(&chgset, parent, ppupdate), "fail update prop\n");
 884	unittest(!of_changeset_remove_property(&chgset, parent, ppremove), "fail remove prop\n");
 885	n22 = of_changeset_create_node(&chgset, n2, "n22");
 886	unittest(n22, "fail create n22\n");
 887	unittest(!of_changeset_add_prop_string(&chgset, n22, "prop-str", "abcd"),
 888		 "fail add prop prop-str");
 889	unittest(!of_changeset_add_prop_string_array(&chgset, n22, "prop-str-array",
 890						     (const char **)str_array,
 891						     ARRAY_SIZE(str_array)),
 892		 "fail add prop prop-str-array");
 893	unittest(!of_changeset_add_prop_u32_array(&chgset, n22, "prop-u32-array",
 894						  u32_array, ARRAY_SIZE(u32_array)),
 895		 "fail add prop prop-u32-array");
 896
 897	unittest(!of_changeset_apply(&chgset), "apply failed\n");
 898
 899	of_node_put(nchangeset);
 900
 901	/* Make sure node names are constructed correctly */
 902	unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n21")),
 903		 "'%pOF' not added\n", n21);
 904	of_node_put(np);
 905	unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n22")),
 906		 "'%pOF' not added\n", n22);
 907	of_node_put(np);
 908
 909	unittest(!of_changeset_revert(&chgset), "revert failed\n");
 910
 911	unittest(!of_find_node_by_path("/testcase-data/changeset/n2/n21"),
 912		 "'%pOF' still present after revert\n", n21);
 913
 914	unittest(of_property_present(parent, "prop-remove"),
 915		 "failed to find removed prop after revert\n");
 916
 917	ret = of_property_read_string(parent, "prop-update", &propstr);
 918	unittest(!ret, "failed to find updated prop after revert\n");
 919	if (!ret)
 920		unittest(strcmp(propstr, "hello") == 0, "original value not in updated property after revert");
 921
 922	of_changeset_destroy(&chgset);
 923
 924	of_node_put(n1);
 925	of_node_put(n2);
 926	of_node_put(n21);
 927	of_node_put(n22);
 928#endif
 929}
 930
 931static void __init __maybe_unused changeset_check_string(struct device_node *np,
 932							 const char *prop_name,
 933							 const char *expected_str)
 934{
 935	const char *str;
 936	int ret;
 937
 938	ret = of_property_read_string(np, prop_name, &str);
 939	if (unittest(ret == 0, "failed to read %s\n", prop_name))
 940		return;
 941
 942	unittest(strcmp(str, expected_str) == 0,
 943		 "%s value mismatch (read '%s', exp '%s')\n",
 944		 prop_name, str, expected_str);
 945}
 946
 947static void __init __maybe_unused changeset_check_string_array(struct device_node *np,
 948							       const char *prop_name,
 949							       const char * const *expected_array,
 950							       unsigned int count)
 951{
 952	const char *str;
 953	unsigned int i;
 954	int ret;
 955	int cnt;
 956
 957	cnt = of_property_count_strings(np, prop_name);
 958	if (unittest(cnt >= 0, "failed to get %s count\n", prop_name))
 959		return;
 960
 961	if (unittest(cnt == count,
 962		     "%s count mismatch (read %d, exp %u)\n",
 963		     prop_name, cnt, count))
 964		return;
 965
 966	for (i = 0; i < count; i++) {
 967		ret = of_property_read_string_index(np, prop_name, i, &str);
 968		if (unittest(ret == 0, "failed to read %s[%d]\n", prop_name, i))
 969			continue;
 970
 971		unittest(strcmp(str, expected_array[i]) == 0,
 972			 "%s[%d] value mismatch (read '%s', exp '%s')\n",
 973			 prop_name, i, str, expected_array[i]);
 974	}
 975}
 976
 977static void __init __maybe_unused changeset_check_u32(struct device_node *np,
 978						      const char *prop_name,
 979						      u32 expected_u32)
 980{
 981	u32 val32;
 982	int ret;
 983
 984	ret = of_property_read_u32(np, prop_name, &val32);
 985	if (unittest(ret == 0, "failed to read %s\n", prop_name))
 986		return;
 987
 988	unittest(val32 == expected_u32,
 989		 "%s value mismatch (read '%u', exp '%u')\n",
 990		 prop_name, val32, expected_u32);
 991}
 992
 993static void __init __maybe_unused changeset_check_u32_array(struct device_node *np,
 994							    const char *prop_name,
 995							    const u32 *expected_array,
 996							    unsigned int count)
 997{
 998	unsigned int i;
 999	u32 val32;
1000	int ret;
1001	int cnt;
1002
1003	cnt = of_property_count_u32_elems(np, prop_name);
1004	if (unittest(cnt >= 0, "failed to get %s count\n", prop_name))
1005		return;
1006
1007	if (unittest(cnt == count,
1008		     "%s count mismatch (read %d, exp %u)\n",
1009		     prop_name, cnt, count))
1010		return;
1011
1012	for (i = 0; i < count; i++) {
1013		ret = of_property_read_u32_index(np, prop_name, i, &val32);
1014		if (unittest(ret == 0, "failed to read %s[%d]\n", prop_name, i))
1015			continue;
1016
1017		unittest(val32 == expected_array[i],
1018			 "%s[%d] value mismatch (read '%u', exp '%u')\n",
1019			 prop_name, i, val32, expected_array[i]);
1020	}
1021}
1022
1023static void __init __maybe_unused changeset_check_bool(struct device_node *np,
1024						       const char *prop_name)
1025{
1026	unittest(of_property_read_bool(np, prop_name),
1027		 "%s value mismatch (read 'false', exp 'true')\n", prop_name);
1028}
1029
1030static void __init of_unittest_changeset_prop(void)
1031{
1032#ifdef CONFIG_OF_DYNAMIC
1033	static const char * const str_array[] = { "abc", "defg", "hij" };
1034	static const u32 u32_array[] = { 123, 4567, 89, 10, 11 };
1035	struct device_node *nchangeset, *np;
1036	struct of_changeset chgset;
1037	int ret;
1038
1039	nchangeset = of_find_node_by_path("/testcase-data/changeset");
1040	if (!nchangeset) {
1041		pr_err("missing testcase data\n");
1042		return;
1043	}
1044
1045	of_changeset_init(&chgset);
1046
1047	np = of_changeset_create_node(&chgset, nchangeset, "test-prop");
1048	if (unittest(np, "failed to create test-prop node\n"))
1049		goto end_changeset_destroy;
1050
1051	ret = of_changeset_add_prop_string(&chgset, np, "prop-string", "abcde");
1052	unittest(ret == 0, "failed to add prop-string\n");
1053
1054	ret = of_changeset_add_prop_string_array(&chgset, np, "prop-string-array",
1055						 str_array, ARRAY_SIZE(str_array));
1056	unittest(ret == 0, "failed to add prop-string-array\n");
1057
1058	ret = of_changeset_add_prop_u32(&chgset, np, "prop-u32", 1234);
1059	unittest(ret == 0, "failed to add prop-u32\n");
1060
1061	ret = of_changeset_add_prop_u32_array(&chgset, np, "prop-u32-array",
1062					      u32_array, ARRAY_SIZE(u32_array));
1063	unittest(ret == 0, "failed to add prop-u32-array\n");
1064
1065	ret = of_changeset_add_prop_bool(&chgset, np, "prop-bool");
1066	unittest(ret == 0, "failed to add prop-bool\n");
1067
1068	of_node_put(np);
1069
1070	ret = of_changeset_apply(&chgset);
1071	if (unittest(ret == 0, "failed to apply changeset\n"))
1072		goto end_changeset_destroy;
1073
1074	np = of_find_node_by_path("/testcase-data/changeset/test-prop");
1075	if (unittest(np, "failed to find test-prop node\n"))
1076		goto end_revert_changeset;
1077
1078	changeset_check_string(np, "prop-string", "abcde");
1079	changeset_check_string_array(np, "prop-string-array", str_array, ARRAY_SIZE(str_array));
1080	changeset_check_u32(np, "prop-u32", 1234);
1081	changeset_check_u32_array(np, "prop-u32-array", u32_array, ARRAY_SIZE(u32_array));
1082	changeset_check_bool(np, "prop-bool");
1083
1084	of_node_put(np);
1085
1086end_revert_changeset:
1087	ret = of_changeset_revert(&chgset);
1088	unittest(ret == 0, "failed to revert changeset\n");
1089
1090end_changeset_destroy:
1091	of_changeset_destroy(&chgset);
1092	of_node_put(nchangeset);
1093#endif
1094}
1095
1096static void __init of_unittest_dma_get_max_cpu_address(void)
1097{
1098	struct device_node *np;
1099	phys_addr_t cpu_addr;
1100
1101	if (!IS_ENABLED(CONFIG_OF_ADDRESS))
1102		return;
1103
1104	np = of_find_node_by_path("/testcase-data/address-tests");
1105	if (!np) {
1106		pr_err("missing testcase data\n");
1107		return;
1108	}
1109
1110	cpu_addr = of_dma_get_max_cpu_address(np);
1111	unittest(cpu_addr == 0x4fffffff,
1112		 "of_dma_get_max_cpu_address: wrong CPU addr %pad (expecting %x)\n",
1113		 &cpu_addr, 0x4fffffff);
1114}
1115
1116static void __init of_unittest_dma_ranges_one(const char *path,
1117		u64 expect_dma_addr, u64 expect_paddr)
1118{
1119#ifdef CONFIG_HAS_DMA
1120	struct device_node *np;
1121	const struct bus_dma_region *map = NULL;
1122	int rc;
1123
1124	np = of_find_node_by_path(path);
1125	if (!np) {
1126		pr_err("missing testcase data\n");
1127		return;
1128	}
1129
1130	rc = of_dma_get_range(np, &map);
1131
1132	unittest(!rc, "of_dma_get_range failed on node %pOF rc=%i\n", np, rc);
1133
1134	if (!rc) {
1135		phys_addr_t	paddr;
1136		dma_addr_t	dma_addr;
1137		struct device	*dev_bogus;
1138
1139		dev_bogus = kzalloc(sizeof(struct device), GFP_KERNEL);
1140		if (!dev_bogus) {
1141			unittest(0, "kzalloc() failed\n");
1142			kfree(map);
1143			return;
1144		}
1145
1146		dev_bogus->dma_range_map = map;
1147		paddr = dma_to_phys(dev_bogus, expect_dma_addr);
1148		dma_addr = phys_to_dma(dev_bogus, expect_paddr);
1149
1150		unittest(paddr == expect_paddr,
1151			 "of_dma_get_range: wrong phys addr %pap (expecting %llx) on node %pOF\n",
1152			 &paddr, expect_paddr, np);
1153		unittest(dma_addr == expect_dma_addr,
1154			 "of_dma_get_range: wrong DMA addr %pad (expecting %llx) on node %pOF\n",
1155			 &dma_addr, expect_dma_addr, np);
1156
1157		kfree(map);
1158		kfree(dev_bogus);
1159	}
1160	of_node_put(np);
1161#endif
1162}
1163
1164static void __init of_unittest_parse_dma_ranges(void)
1165{
1166	of_unittest_dma_ranges_one("/testcase-data/address-tests/device@70000000",
1167		0x0, 0x20000000);
1168	if (IS_ENABLED(CONFIG_ARCH_DMA_ADDR_T_64BIT))
1169		of_unittest_dma_ranges_one("/testcase-data/address-tests/bus@80000000/device@1000",
1170			0x100000000, 0x20000000);
1171	of_unittest_dma_ranges_one("/testcase-data/address-tests/pci@90000000",
1172		0x80000000, 0x20000000);
1173}
1174
1175static void __init of_unittest_pci_dma_ranges(void)
1176{
1177	struct device_node *np;
1178	struct of_pci_range range;
1179	struct of_pci_range_parser parser;
1180	int i = 0;
1181
1182	if (!IS_ENABLED(CONFIG_PCI))
1183		return;
1184
1185	np = of_find_node_by_path("/testcase-data/address-tests/pci@90000000");
1186	if (!np) {
1187		pr_err("missing testcase data\n");
1188		return;
1189	}
1190
1191	if (of_pci_dma_range_parser_init(&parser, np)) {
1192		pr_err("missing dma-ranges property\n");
1193		return;
1194	}
1195
1196	/*
1197	 * Get the dma-ranges from the device tree
1198	 */
1199	for_each_of_pci_range(&parser, &range) {
1200		if (!i) {
1201			unittest(range.size == 0x10000000,
1202				 "for_each_of_pci_range wrong size on node %pOF size=%llx\n",
1203				 np, range.size);
1204			unittest(range.cpu_addr == 0x20000000,
1205				 "for_each_of_pci_range wrong CPU addr (%llx) on node %pOF",
1206				 range.cpu_addr, np);
1207			unittest(range.pci_addr == 0x80000000,
1208				 "for_each_of_pci_range wrong DMA addr (%llx) on node %pOF",
1209				 range.pci_addr, np);
1210		} else {
1211			unittest(range.size == 0x10000000,
1212				 "for_each_of_pci_range wrong size on node %pOF size=%llx\n",
1213				 np, range.size);
1214			unittest(range.cpu_addr == 0x40000000,
1215				 "for_each_of_pci_range wrong CPU addr (%llx) on node %pOF",
1216				 range.cpu_addr, np);
1217			unittest(range.pci_addr == 0xc0000000,
1218				 "for_each_of_pci_range wrong DMA addr (%llx) on node %pOF",
1219				 range.pci_addr, np);
1220		}
1221		i++;
1222	}
1223
1224	of_node_put(np);
1225}
1226
1227static void __init of_unittest_pci_empty_dma_ranges(void)
1228{
1229	struct device_node *np;
1230	struct of_pci_range range;
1231	struct of_pci_range_parser parser;
1232
1233	if (!IS_ENABLED(CONFIG_PCI))
1234		return;
1235
1236	np = of_find_node_by_path("/testcase-data/address-tests2/pcie@d1070000/pci@0,0/dev@0,0/local-bus@0");
1237	if (!np) {
1238		pr_err("missing testcase data\n");
1239		return;
1240	}
1241
1242	if (of_pci_dma_range_parser_init(&parser, np)) {
1243		pr_err("missing dma-ranges property\n");
1244		return;
1245	}
1246
1247	/*
1248	 * Get the dma-ranges from the device tree
1249	 */
1250	for_each_of_pci_range(&parser, &range) {
1251		unittest(range.size == 0x10000000,
1252			 "for_each_of_pci_range wrong size on node %pOF size=%llx\n",
1253			 np, range.size);
1254		unittest(range.cpu_addr == 0x00000000,
1255			 "for_each_of_pci_range wrong CPU addr (%llx) on node %pOF",
1256			 range.cpu_addr, np);
1257		unittest(range.pci_addr == 0xc0000000,
1258			 "for_each_of_pci_range wrong DMA addr (%llx) on node %pOF",
1259			 range.pci_addr, np);
1260	}
1261
1262	of_node_put(np);
1263}
1264
1265static void __init of_unittest_bus_ranges(void)
1266{
1267	struct device_node *np;
1268	struct of_range range;
1269	struct of_range_parser parser;
1270	struct resource res;
1271	int ret, count, i = 0;
1272
1273	np = of_find_node_by_path("/testcase-data/address-tests");
1274	if (!np) {
1275		pr_err("missing testcase data\n");
1276		return;
1277	}
1278
1279	if (of_range_parser_init(&parser, np)) {
1280		pr_err("missing ranges property\n");
1281		return;
1282	}
1283
1284	ret = of_range_to_resource(np, 1, &res);
1285	unittest(!ret, "of_range_to_resource returned error (%d) node %pOF\n",
1286		ret, np);
1287	unittest(resource_type(&res) == IORESOURCE_MEM,
1288		"of_range_to_resource wrong resource type on node %pOF res=%pR\n",
1289		np, &res);
1290	unittest(res.start == 0xd0000000,
1291		"of_range_to_resource wrong resource start address on node %pOF res=%pR\n",
1292		np, &res);
1293	unittest(resource_size(&res) == 0x20000000,
1294		"of_range_to_resource wrong resource start address on node %pOF res=%pR\n",
1295		np, &res);
1296
1297	count = of_range_count(&parser);
1298	unittest(count == 2,
1299		"of_range_count wrong size on node %pOF count=%d\n",
1300		np, count);
1301
1302	/*
1303	 * Get the "ranges" from the device tree
1304	 */
1305	for_each_of_range(&parser, &range) {
1306		unittest(range.flags == IORESOURCE_MEM,
1307			"for_each_of_range wrong flags on node %pOF flags=%x (expected %x)\n",
1308			np, range.flags, IORESOURCE_MEM);
1309		if (!i) {
1310			unittest(range.size == 0x50000000,
1311				 "for_each_of_range wrong size on node %pOF size=%llx\n",
1312				 np, range.size);
1313			unittest(range.cpu_addr == 0x70000000,
1314				 "for_each_of_range wrong CPU addr (%llx) on node %pOF",
1315				 range.cpu_addr, np);
1316			unittest(range.bus_addr == 0x70000000,
1317				 "for_each_of_range wrong bus addr (%llx) on node %pOF",
1318				 range.pci_addr, np);
1319		} else {
1320			unittest(range.size == 0x20000000,
1321				 "for_each_of_range wrong size on node %pOF size=%llx\n",
1322				 np, range.size);
1323			unittest(range.cpu_addr == 0xd0000000,
1324				 "for_each_of_range wrong CPU addr (%llx) on node %pOF",
1325				 range.cpu_addr, np);
1326			unittest(range.bus_addr == 0x00000000,
1327				 "for_each_of_range wrong bus addr (%llx) on node %pOF",
1328				 range.pci_addr, np);
1329		}
1330		i++;
1331	}
1332
1333	of_node_put(np);
1334}
1335
1336static void __init of_unittest_bus_3cell_ranges(void)
1337{
1338	struct device_node *np;
1339	struct of_range range;
1340	struct of_range_parser parser;
1341	int i = 0;
1342
1343	np = of_find_node_by_path("/testcase-data/address-tests/bus@a0000000");
1344	if (!np) {
1345		pr_err("missing testcase data\n");
1346		return;
1347	}
1348
1349	if (of_range_parser_init(&parser, np)) {
1350		pr_err("missing ranges property\n");
1351		return;
1352	}
1353
1354	/*
1355	 * Get the "ranges" from the device tree
1356	 */
1357	for_each_of_range(&parser, &range) {
1358		if (!i) {
1359			unittest(range.flags == 0xf00baa,
1360				 "for_each_of_range wrong flags on node %pOF flags=%x\n",
1361				 np, range.flags);
1362			unittest(range.size == 0x100000,
1363				 "for_each_of_range wrong size on node %pOF size=%llx\n",
1364				 np, range.size);
1365			unittest(range.cpu_addr == 0xa0000000,
1366				 "for_each_of_range wrong CPU addr (%llx) on node %pOF",
1367				 range.cpu_addr, np);
1368			unittest(range.bus_addr == 0x0,
1369				 "for_each_of_range wrong bus addr (%llx) on node %pOF",
1370				 range.pci_addr, np);
1371		} else {
1372			unittest(range.flags == 0xf00bee,
1373				 "for_each_of_range wrong flags on node %pOF flags=%x\n",
1374				 np, range.flags);
1375			unittest(range.size == 0x200000,
1376				 "for_each_of_range wrong size on node %pOF size=%llx\n",
1377				 np, range.size);
1378			unittest(range.cpu_addr == 0xb0000000,
1379				 "for_each_of_range wrong CPU addr (%llx) on node %pOF",
1380				 range.cpu_addr, np);
1381			unittest(range.bus_addr == 0x100000000,
1382				 "for_each_of_range wrong bus addr (%llx) on node %pOF",
1383				 range.pci_addr, np);
1384		}
1385		i++;
1386	}
1387
1388	of_node_put(np);
1389}
1390
1391static void __init of_unittest_reg(void)
1392{
1393	struct device_node *np;
1394	struct resource res;
1395	int ret;
1396	u64 addr, size;
1397
1398	np = of_find_node_by_path("/testcase-data/address-tests/bus@80000000/device@1000");
1399	if (!np) {
1400		pr_err("missing testcase data\n");
1401		return;
1402	}
1403
1404	ret = of_property_read_reg(np, 0, &addr, &size);
1405	unittest(!ret, "of_property_read_reg(%pOF) returned error %d\n",
1406		np, ret);
1407	unittest(addr == 0x1000, "of_property_read_reg(%pOF) untranslated address (%llx) incorrect\n",
1408		np, addr);
1409
1410	of_node_put(np);
1411
1412	np = of_find_node_by_path("/testcase-data/platform-tests-2/node/test-device@100");
1413	if (!np) {
1414		pr_err("missing testcase data\n");
1415		return;
1416	}
1417
1418	ret = of_address_to_resource(np, 0, &res);
1419	unittest(ret == -EINVAL, "of_address_to_resource(%pOF) expected error on untranslatable address\n",
1420		 np);
1421
1422	of_node_put(np);
1423
1424}
1425
1426struct of_unittest_expected_res {
1427	int index;
1428	struct resource res;
1429};
1430
1431static void __init of_unittest_check_addr(const char *node_path,
1432					  const struct of_unittest_expected_res *tab_exp,
1433					  unsigned int tab_exp_count)
1434{
1435	const struct of_unittest_expected_res *expected;
1436	struct device_node *np;
1437	struct resource res;
1438	unsigned int count;
1439	int ret;
1440
1441	if (!IS_ENABLED(CONFIG_OF_ADDRESS))
1442		return;
1443
1444	np = of_find_node_by_path(node_path);
1445	if (!np) {
1446		pr_err("missing testcase data (%s)\n", node_path);
1447		return;
1448	}
1449
1450	expected = tab_exp;
1451	count = tab_exp_count;
1452	while (count--) {
1453		ret = of_address_to_resource(np, expected->index, &res);
1454		unittest(!ret, "of_address_to_resource(%pOF, %d) returned error %d\n",
1455			 np, expected->index, ret);
1456		unittest(resource_type(&res) == resource_type(&expected->res) &&
1457			 res.start == expected->res.start &&
1458			 resource_size(&res) == resource_size(&expected->res),
1459			"of_address_to_resource(%pOF, %d) wrong resource %pR, expected %pR\n",
1460			np, expected->index, &res, &expected->res);
1461		expected++;
1462	}
1463
1464	of_node_put(np);
1465}
1466
1467static const struct of_unittest_expected_res of_unittest_reg_2cell_expected_res[] = {
1468	{.index = 0, .res = DEFINE_RES_MEM(0xa0a01000, 0x100) },
1469	{.index = 1, .res = DEFINE_RES_MEM(0xa0a02000, 0x100) },
1470	{.index = 2, .res = DEFINE_RES_MEM(0xc0c01000, 0x100) },
1471	{.index = 3, .res = DEFINE_RES_MEM(0xd0d01000, 0x100) },
1472};
1473
1474static const struct of_unittest_expected_res of_unittest_reg_3cell_expected_res[] = {
1475	{.index = 0, .res = DEFINE_RES_MEM(0xa0a01000, 0x100) },
1476	{.index = 1, .res = DEFINE_RES_MEM(0xa0b02000, 0x100) },
1477	{.index = 2, .res = DEFINE_RES_MEM(0xc0c01000, 0x100) },
1478	{.index = 3, .res = DEFINE_RES_MEM(0xc0c09000, 0x100) },
1479	{.index = 4, .res = DEFINE_RES_MEM(0xd0d01000, 0x100) },
1480};
1481
1482static const struct of_unittest_expected_res of_unittest_reg_pci_expected_res[] = {
1483	{.index = 0, .res = DEFINE_RES_MEM(0xe8001000, 0x1000) },
1484	{.index = 1, .res = DEFINE_RES_MEM(0xea002000, 0x2000) },
1485};
1486
1487static void __init of_unittest_translate_addr(void)
1488{
1489	of_unittest_check_addr("/testcase-data/address-tests2/bus-2cell@10000000/device@100000",
1490			       of_unittest_reg_2cell_expected_res,
1491			       ARRAY_SIZE(of_unittest_reg_2cell_expected_res));
1492
1493	of_unittest_check_addr("/testcase-data/address-tests2/bus-3cell@20000000/local-bus@100000/device@f1001000",
1494			       of_unittest_reg_3cell_expected_res,
1495			       ARRAY_SIZE(of_unittest_reg_3cell_expected_res));
1496
1497	of_unittest_check_addr("/testcase-data/address-tests2/pcie@d1070000/pci@0,0/dev@0,0/local-bus@0/dev@e0000000",
1498			       of_unittest_reg_pci_expected_res,
1499			       ARRAY_SIZE(of_unittest_reg_pci_expected_res));
1500}
1501
1502static void __init of_unittest_parse_interrupts(void)
1503{
1504	struct device_node *np;
1505	struct of_phandle_args args;
1506	int i, rc;
1507
1508	if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
1509		return;
1510
1511	np = of_find_node_by_path("/testcase-data/interrupts/interrupts0");
1512	if (!np) {
1513		pr_err("missing testcase data\n");
1514		return;
1515	}
1516
1517	for (i = 0; i < 4; i++) {
1518		bool passed = true;
1519
1520		memset(&args, 0, sizeof(args));
1521		rc = of_irq_parse_one(np, i, &args);
1522
1523		passed &= !rc;
1524		passed &= (args.args_count == 1);
1525		passed &= (args.args[0] == (i + 1));
1526
1527		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
1528			 i, args.np, rc);
1529	}
1530	of_node_put(np);
1531
1532	np = of_find_node_by_path("/testcase-data/interrupts/interrupts1");
1533	if (!np) {
1534		pr_err("missing testcase data\n");
1535		return;
1536	}
1537
1538	for (i = 0; i < 4; i++) {
1539		bool passed = true;
1540
1541		memset(&args, 0, sizeof(args));
1542		rc = of_irq_parse_one(np, i, &args);
1543
1544		/* Test the values from tests-phandle.dtsi */
1545		switch (i) {
1546		case 0:
1547			passed &= !rc;
1548			passed &= (args.args_count == 1);
1549			passed &= (args.args[0] == 9);
1550			break;
1551		case 1:
1552			passed &= !rc;
1553			passed &= (args.args_count == 3);
1554			passed &= (args.args[0] == 10);
1555			passed &= (args.args[1] == 11);
1556			passed &= (args.args[2] == 12);
1557			break;
1558		case 2:
1559			passed &= !rc;
1560			passed &= (args.args_count == 2);
1561			passed &= (args.args[0] == 13);
1562			passed &= (args.args[1] == 14);
1563			break;
1564		case 3:
1565			passed &= !rc;
1566			passed &= (args.args_count == 2);
1567			passed &= (args.args[0] == 15);
1568			passed &= (args.args[1] == 16);
1569			break;
1570		default:
1571			passed = false;
1572		}
1573		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
1574			 i, args.np, rc);
1575	}
1576	of_node_put(np);
1577}
1578
1579static void __init of_unittest_parse_interrupts_extended(void)
1580{
1581	struct device_node *np;
1582	struct of_phandle_args args;
1583	int i, rc;
1584
1585	if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
1586		return;
1587
1588	np = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0");
1589	if (!np) {
1590		pr_err("missing testcase data\n");
1591		return;
1592	}
1593
1594	for (i = 0; i < 7; i++) {
1595		bool passed = true;
1596
1597		memset(&args, 0, sizeof(args));
1598		rc = of_irq_parse_one(np, i, &args);
1599
1600		/* Test the values from tests-phandle.dtsi */
1601		switch (i) {
1602		case 0:
1603			passed &= !rc;
1604			passed &= (args.args_count == 1);
1605			passed &= (args.args[0] == 1);
1606			break;
1607		case 1:
1608			passed &= !rc;
1609			passed &= (args.args_count == 3);
1610			passed &= (args.args[0] == 2);
1611			passed &= (args.args[1] == 3);
1612			passed &= (args.args[2] == 4);
1613			break;
1614		case 2:
1615			passed &= !rc;
1616			passed &= (args.args_count == 2);
1617			passed &= (args.args[0] == 5);
1618			passed &= (args.args[1] == 6);
1619			break;
1620		case 3:
1621			passed &= !rc;
1622			passed &= (args.args_count == 1);
1623			passed &= (args.args[0] == 9);
1624			break;
1625		case 4:
1626			passed &= !rc;
1627			passed &= (args.args_count == 3);
1628			passed &= (args.args[0] == 10);
1629			passed &= (args.args[1] == 11);
1630			passed &= (args.args[2] == 12);
1631			break;
1632		case 5:
1633			passed &= !rc;
1634			passed &= (args.args_count == 2);
1635			passed &= (args.args[0] == 13);
1636			passed &= (args.args[1] == 14);
1637			break;
1638		case 6:
1639			/*
1640			 * Tests child node that is missing property
1641			 * #address-cells.  See the comments in
1642			 * drivers/of/unittest-data/tests-interrupts.dtsi
1643			 * nodes intmap1 and interrupts-extended0
1644			 */
1645			passed &= !rc;
1646			passed &= (args.args_count == 1);
1647			passed &= (args.args[0] == 15);
1648			break;
1649		default:
1650			passed = false;
1651		}
1652
1653		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
1654			 i, args.np, rc);
1655	}
1656	of_node_put(np);
1657}
1658
1659#if IS_ENABLED(CONFIG_OF_DYNAMIC)
1660static void __init of_unittest_irq_refcount(void)
1661{
1662	struct of_phandle_args args;
1663	struct device_node *intc0, *int_ext0;
1664	struct device_node *int2, *intc_intmap0;
1665	unsigned int ref_c0, ref_c1, ref_c2;
1666	int rc;
1667	bool passed;
1668
1669	if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
1670		return;
1671
1672	intc0 = of_find_node_by_path("/testcase-data/interrupts/intc0");
1673	int_ext0 = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0");
1674	intc_intmap0 = of_find_node_by_path("/testcase-data/interrupts/intc-intmap0");
1675	int2 = of_find_node_by_path("/testcase-data/interrupts/interrupts2");
1676	if (!intc0 || !int_ext0 || !intc_intmap0 || !int2) {
1677		pr_err("missing testcase data\n");
1678		goto out;
1679	}
1680
1681	/* Test refcount for API of_irq_parse_one() */
1682	passed = true;
1683	ref_c0 = OF_KREF_READ(intc0);
1684	ref_c1 = ref_c0 + 1;
1685	memset(&args, 0, sizeof(args));
1686	rc = of_irq_parse_one(int_ext0, 0, &args);
1687	ref_c2 = OF_KREF_READ(intc0);
1688	of_node_put(args.np);
1689
1690	passed &= !rc;
1691	passed &= (args.np == intc0);
1692	passed &= (args.args_count == 1);
1693	passed &= (args.args[0] == 1);
1694	passed &= (ref_c1 == ref_c2);
1695	unittest(passed, "IRQ refcount case #1 failed, original(%u) expected(%u) got(%u)\n",
1696		 ref_c0, ref_c1, ref_c2);
1697
1698	/* Test refcount for API of_irq_parse_raw() */
1699	passed = true;
1700	ref_c0 = OF_KREF_READ(intc_intmap0);
1701	ref_c1 = ref_c0 + 1;
1702	memset(&args, 0, sizeof(args));
1703	rc = of_irq_parse_one(int2, 0, &args);
1704	ref_c2 = OF_KREF_READ(intc_intmap0);
1705	of_node_put(args.np);
1706
1707	passed &= !rc;
1708	passed &= (args.np == intc_intmap0);
1709	passed &= (args.args_count == 1);
1710	passed &= (args.args[0] == 2);
1711	passed &= (ref_c1 == ref_c2);
1712	unittest(passed, "IRQ refcount case #2 failed, original(%u) expected(%u) got(%u)\n",
1713		 ref_c0, ref_c1, ref_c2);
1714
1715out:
1716	of_node_put(int2);
1717	of_node_put(intc_intmap0);
1718	of_node_put(int_ext0);
1719	of_node_put(intc0);
1720}
1721#else
1722static inline void __init of_unittest_irq_refcount(void) { }
1723#endif
1724
1725static const struct of_device_id match_node_table[] = {
1726	{ .data = "A", .name = "name0", }, /* Name alone is lowest priority */
1727	{ .data = "B", .type = "type1", }, /* followed by type alone */
1728
1729	{ .data = "Ca", .name = "name2", .type = "type1", }, /* followed by both together */
1730	{ .data = "Cb", .name = "name2", }, /* Only match when type doesn't match */
1731	{ .data = "Cc", .name = "name2", .type = "type2", },
1732
1733	{ .data = "E", .compatible = "compat3" },
1734	{ .data = "G", .compatible = "compat2", },
1735	{ .data = "H", .compatible = "compat2", .name = "name5", },
1736	{ .data = "I", .compatible = "compat2", .type = "type1", },
1737	{ .data = "J", .compatible = "compat2", .type = "type1", .name = "name8", },
1738	{ .data = "K", .compatible = "compat2", .name = "name9", },
1739	{}
1740};
1741
1742static struct {
1743	const char *path;
1744	const char *data;
1745} match_node_tests[] = {
1746	{ .path = "/testcase-data/match-node/name0", .data = "A", },
1747	{ .path = "/testcase-data/match-node/name1", .data = "B", },
1748	{ .path = "/testcase-data/match-node/a/name2", .data = "Ca", },
1749	{ .path = "/testcase-data/match-node/b/name2", .data = "Cb", },
1750	{ .path = "/testcase-data/match-node/c/name2", .data = "Cc", },
1751	{ .path = "/testcase-data/match-node/name3", .data = "E", },
1752	{ .path = "/testcase-data/match-node/name4", .data = "G", },
1753	{ .path = "/testcase-data/match-node/name5", .data = "H", },
1754	{ .path = "/testcase-data/match-node/name6", .data = "G", },
1755	{ .path = "/testcase-data/match-node/name7", .data = "I", },
1756	{ .path = "/testcase-data/match-node/name8", .data = "J", },
1757	{ .path = "/testcase-data/match-node/name9", .data = "K", },
1758};
1759
1760static void __init of_unittest_match_node(void)
1761{
1762	struct device_node *np;
1763	const struct of_device_id *match;
1764	int i;
1765
1766	for (i = 0; i < ARRAY_SIZE(match_node_tests); i++) {
1767		np = of_find_node_by_path(match_node_tests[i].path);
1768		if (!np) {
1769			unittest(0, "missing testcase node %s\n",
1770				match_node_tests[i].path);
1771			continue;
1772		}
1773
1774		match = of_match_node(match_node_table, np);
1775		if (!match) {
1776			unittest(0, "%s didn't match anything\n",
1777				match_node_tests[i].path);
1778			continue;
1779		}
1780
1781		if (strcmp(match->data, match_node_tests[i].data) != 0) {
1782			unittest(0, "%s got wrong match. expected %s, got %s\n",
1783				match_node_tests[i].path, match_node_tests[i].data,
1784				(const char *)match->data);
1785			continue;
1786		}
1787		unittest(1, "passed");
1788	}
1789}
1790
1791static struct resource test_bus_res = DEFINE_RES_MEM(0xfffffff8, 2);
1792static const struct platform_device_info test_bus_info = {
1793	.name = "unittest-bus",
1794};
1795static void __init of_unittest_platform_populate(void)
1796{
1797	int irq, rc;
1798	struct device_node *np, *child, *grandchild;
1799	struct platform_device *pdev, *test_bus;
1800	const struct of_device_id match[] = {
1801		{ .compatible = "test-device", },
1802		{}
1803	};
1804
1805	np = of_find_node_by_path("/testcase-data");
1806	of_platform_default_populate(np, NULL, NULL);
1807
1808	/* Test that a missing irq domain returns -EPROBE_DEFER */
1809	np = of_find_node_by_path("/testcase-data/testcase-device1");
1810	pdev = of_find_device_by_node(np);
1811	unittest(pdev, "device 1 creation failed\n");
1812
1813	if (!(of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)) {
1814		irq = platform_get_irq(pdev, 0);
1815		unittest(irq == -EPROBE_DEFER,
1816			 "device deferred probe failed - %d\n", irq);
1817
1818		/* Test that a parsing failure does not return -EPROBE_DEFER */
1819		np = of_find_node_by_path("/testcase-data/testcase-device2");
1820		pdev = of_find_device_by_node(np);
1821		unittest(pdev, "device 2 creation failed\n");
1822
1823		EXPECT_BEGIN(KERN_INFO,
1824			     "platform testcase-data:testcase-device2: error -ENXIO: IRQ index 0 not found");
1825
1826		irq = platform_get_irq(pdev, 0);
1827
1828		EXPECT_END(KERN_INFO,
1829			   "platform testcase-data:testcase-device2: error -ENXIO: IRQ index 0 not found");
1830
1831		unittest(irq < 0 && irq != -EPROBE_DEFER,
1832			 "device parsing error failed - %d\n", irq);
1833	}
1834
1835	np = of_find_node_by_path("/testcase-data/platform-tests");
1836	unittest(np, "No testcase data in device tree\n");
1837	if (!np)
1838		return;
1839
1840	test_bus = platform_device_register_full(&test_bus_info);
1841	rc = PTR_ERR_OR_ZERO(test_bus);
1842	unittest(!rc, "testbus registration failed; rc=%i\n", rc);
1843	if (rc) {
1844		of_node_put(np);
1845		return;
1846	}
1847	test_bus->dev.of_node = np;
1848
1849	/*
1850	 * Add a dummy resource to the test bus node after it is
1851	 * registered to catch problems with un-inserted resources. The
1852	 * DT code doesn't insert the resources, and it has caused the
1853	 * kernel to oops in the past. This makes sure the same bug
1854	 * doesn't crop up again.
1855	 */
1856	platform_device_add_resources(test_bus, &test_bus_res, 1);
1857
1858	of_platform_populate(np, match, NULL, &test_bus->dev);
1859	for_each_child_of_node(np, child) {
1860		for_each_child_of_node(child, grandchild) {
1861			if (!of_property_present(grandchild, "compatible"))
1862				continue;
1863			pdev = of_find_device_by_node(grandchild);
1864			unittest(pdev,
1865				 "Could not create device for node '%pOFn'\n",
1866				 grandchild);
1867			platform_device_put(pdev);
1868		}
1869	}
1870
1871	of_platform_depopulate(&test_bus->dev);
1872	for_each_child_of_node(np, child) {
1873		for_each_child_of_node(child, grandchild)
1874			unittest(!of_find_device_by_node(grandchild),
1875				 "device didn't get destroyed '%pOFn'\n",
1876				 grandchild);
1877	}
1878
1879	platform_device_unregister(test_bus);
1880	of_node_put(np);
1881}
1882
1883/**
1884 *	update_node_properties - adds the properties
1885 *	of np into dup node (present in live tree) and
1886 *	updates parent of children of np to dup.
1887 *
1888 *	@np:	node whose properties are being added to the live tree
1889 *	@dup:	node present in live tree to be updated
1890 */
1891static void update_node_properties(struct device_node *np,
1892					struct device_node *dup)
1893{
1894	struct property *prop;
1895	struct property *save_next;
1896	struct device_node *child;
1897	int ret;
1898
1899	for_each_child_of_node(np, child)
1900		child->parent = dup;
1901
1902	/*
1903	 * "unittest internal error: unable to add testdata property"
1904	 *
1905	 *    If this message reports a property in node '/__symbols__' then
1906	 *    the respective unittest overlay contains a label that has the
1907	 *    same name as a label in the live devicetree.  The label will
1908	 *    be in the live devicetree only if the devicetree source was
1909	 *    compiled with the '-@' option.  If you encounter this error,
1910	 *    please consider renaming __all__ of the labels in the unittest
1911	 *    overlay dts files with an odd prefix that is unlikely to be
1912	 *    used in a real devicetree.
1913	 */
1914
1915	/*
1916	 * open code for_each_property_of_node() because of_add_property()
1917	 * sets prop->next to NULL
1918	 */
1919	for (prop = np->properties; prop != NULL; prop = save_next) {
1920		save_next = prop->next;
1921		ret = of_add_property(dup, prop);
1922		if (ret) {
1923			if (ret == -EEXIST && !strcmp(prop->name, "name"))
1924				continue;
1925			pr_err("unittest internal error: unable to add testdata property %pOF/%s",
1926			       np, prop->name);
1927		}
1928	}
1929}
1930
1931/**
1932 *	attach_node_and_children - attaches nodes
1933 *	and its children to live tree.
1934 *	CAUTION: misleading function name - if node @np already exists in
1935 *	the live tree then children of @np are *not* attached to the live
1936 *	tree.  This works for the current test devicetree nodes because such
1937 *	nodes do not have child nodes.
1938 *
1939 *	@np:	Node to attach to live tree
1940 */
1941static void attach_node_and_children(struct device_node *np)
1942{
1943	struct device_node *next, *dup, *child;
1944	unsigned long flags;
1945	const char *full_name;
1946
1947	full_name = kasprintf(GFP_KERNEL, "%pOF", np);
1948	if (!full_name)
1949		return;
1950
1951	if (!strcmp(full_name, "/__local_fixups__") ||
1952	    !strcmp(full_name, "/__fixups__")) {
1953		kfree(full_name);
1954		return;
1955	}
1956
1957	dup = of_find_node_by_path(full_name);
1958	kfree(full_name);
1959	if (dup) {
1960		update_node_properties(np, dup);
1961		return;
1962	}
1963
1964	child = np->child;
1965	np->child = NULL;
1966
1967	mutex_lock(&of_mutex);
1968	raw_spin_lock_irqsave(&devtree_lock, flags);
1969	np->sibling = np->parent->child;
1970	np->parent->child = np;
1971	of_node_clear_flag(np, OF_DETACHED);
1972	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1973
1974	__of_attach_node_sysfs(np);
1975	mutex_unlock(&of_mutex);
1976
1977	while (child) {
1978		next = child->sibling;
1979		attach_node_and_children(child);
1980		child = next;
1981	}
1982}
1983
1984/**
1985 *	unittest_data_add - Reads, copies data from
1986 *	linked tree and attaches it to the live tree
1987 */
1988static int __init unittest_data_add(void)
1989{
1990	void *unittest_data_align;
1991	struct device_node *unittest_data_node = NULL, *np;
1992	/*
1993	 * __dtbo_testcases_begin[] and __dtbo_testcases_end[] are magically
1994	 * created by cmd_wrap_S_dtbo in scripts/Makefile.dtbs
1995	 */
1996	extern uint8_t __dtbo_testcases_begin[];
1997	extern uint8_t __dtbo_testcases_end[];
1998	const int size = __dtbo_testcases_end - __dtbo_testcases_begin;
1999	int rc;
2000	void *ret;
2001
2002	if (!size) {
2003		pr_warn("%s: testcases is empty\n", __func__);
2004		return -ENODATA;
2005	}
2006
2007	/* creating copy */
2008	void *unittest_data __free(kfree) = kmalloc(size + FDT_ALIGN_SIZE, GFP_KERNEL);
2009	if (!unittest_data)
2010		return -ENOMEM;
2011
2012	unittest_data_align = PTR_ALIGN(unittest_data, FDT_ALIGN_SIZE);
2013	memcpy(unittest_data_align, __dtbo_testcases_begin, size);
2014
2015	ret = of_fdt_unflatten_tree(unittest_data_align, NULL, &unittest_data_node);
2016	if (!ret) {
2017		pr_warn("%s: unflatten testcases tree failed\n", __func__);
2018		return -ENODATA;
2019	}
2020	if (!unittest_data_node) {
2021		pr_warn("%s: testcases tree is empty\n", __func__);
2022		return -ENODATA;
2023	}
2024
2025	/*
2026	 * This lock normally encloses of_resolve_phandles()
2027	 */
2028	of_overlay_mutex_lock();
2029
2030	rc = of_resolve_phandles(unittest_data_node);
2031	if (rc) {
2032		pr_err("%s: Failed to resolve phandles (rc=%i)\n", __func__, rc);
2033		rc = -EINVAL;
2034		goto unlock;
2035	}
2036
2037	/* attach the sub-tree to live tree */
2038	if (!of_root) {
2039		pr_warn("%s: no live tree to attach sub-tree\n", __func__);
2040		rc = -ENODEV;
2041		goto unlock;
2042	}
2043
2044	EXPECT_BEGIN(KERN_INFO,
2045		     "Duplicate name in testcase-data, renamed to \"duplicate-name#1\"");
2046
2047	np = unittest_data_node->child;
2048	while (np) {
2049		struct device_node *next = np->sibling;
2050
2051		np->parent = of_root;
2052		/* this will clear OF_DETACHED in np and children */
2053		attach_node_and_children(np);
2054		np = next;
2055	}
2056
2057	EXPECT_END(KERN_INFO,
2058		   "Duplicate name in testcase-data, renamed to \"duplicate-name#1\"");
2059
2060	retain_and_null_ptr(unittest_data);
2061
2062unlock:
2063	of_overlay_mutex_unlock();
2064
2065	return rc;
2066}
2067
2068#ifdef CONFIG_OF_OVERLAY
2069static int __init overlay_data_apply(const char *overlay_name, int *ovcs_id);
2070
2071static int unittest_probe(struct platform_device *pdev)
2072{
2073	struct device *dev = &pdev->dev;
2074	struct device_node *np = dev->of_node;
2075
2076	if (np == NULL) {
2077		dev_err(dev, "No OF data for device\n");
2078		return -EINVAL;
2079
2080	}
2081
2082	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2083
2084	of_platform_populate(np, NULL, NULL, &pdev->dev);
2085
2086	return 0;
2087}
2088
2089static void unittest_remove(struct platform_device *pdev)
2090{
2091	struct device *dev = &pdev->dev;
2092	struct device_node *np = dev->of_node;
2093
2094	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2095}
2096
2097static const struct of_device_id unittest_match[] = {
2098	{ .compatible = "unittest", },
2099	{},
2100};
2101
2102static struct platform_driver unittest_driver = {
2103	.probe			= unittest_probe,
2104	.remove			= unittest_remove,
2105	.driver = {
2106		.name		= "unittest",
2107		.of_match_table	= unittest_match,
2108	},
2109};
2110
2111/* get the platform device instantiated at the path */
2112static struct platform_device *of_path_to_platform_device(const char *path)
2113{
2114	struct device_node *np;
2115	struct platform_device *pdev;
2116
2117	np = of_find_node_by_path(path);
2118	if (np == NULL)
2119		return NULL;
2120
2121	pdev = of_find_device_by_node(np);
2122	of_node_put(np);
2123
2124	return pdev;
2125}
2126
2127/* find out if a platform device exists at that path */
2128static int of_path_platform_device_exists(const char *path)
2129{
2130	struct platform_device *pdev;
2131
2132	pdev = of_path_to_platform_device(path);
2133	platform_device_put(pdev);
2134	return pdev != NULL;
2135}
2136
2137#ifdef CONFIG_OF_GPIO
2138
2139struct unittest_gpio_dev {
2140	struct gpio_chip chip;
2141};
2142
2143static int unittest_gpio_chip_request_count;
2144static int unittest_gpio_probe_count;
2145static int unittest_gpio_probe_pass_count;
2146
2147static int unittest_gpio_chip_request(struct gpio_chip *chip, unsigned int offset)
2148{
2149	unittest_gpio_chip_request_count++;
2150
2151	pr_debug("%s(): %s %d %d\n", __func__, chip->label, offset,
2152		 unittest_gpio_chip_request_count);
2153	return 0;
2154}
2155
2156static int unittest_gpio_probe(struct platform_device *pdev)
2157{
2158	struct unittest_gpio_dev *devptr;
2159	int ret;
2160
2161	unittest_gpio_probe_count++;
2162
2163	devptr = kzalloc(sizeof(*devptr), GFP_KERNEL);
2164	if (!devptr)
2165		return -ENOMEM;
2166
2167	platform_set_drvdata(pdev, devptr);
2168
2169	devptr->chip.fwnode = dev_fwnode(&pdev->dev);
2170	devptr->chip.label = "of-unittest-gpio";
2171	devptr->chip.base = -1; /* dynamic allocation */
2172	devptr->chip.ngpio = 5;
2173	devptr->chip.request = unittest_gpio_chip_request;
2174
2175	ret = gpiochip_add_data(&devptr->chip, NULL);
2176
2177	unittest(!ret,
2178		 "gpiochip_add_data() for node @%pfw failed, ret = %d\n", devptr->chip.fwnode, ret);
2179
2180	if (!ret)
2181		unittest_gpio_probe_pass_count++;
2182	return ret;
2183}
2184
2185static void unittest_gpio_remove(struct platform_device *pdev)
2186{
2187	struct unittest_gpio_dev *devptr = platform_get_drvdata(pdev);
2188	struct device *dev = &pdev->dev;
2189
2190	dev_dbg(dev, "%s for node @%pfw\n", __func__, devptr->chip.fwnode);
2191
2192	if (devptr->chip.base != -1)
2193		gpiochip_remove(&devptr->chip);
2194
2195	kfree(devptr);
2196}
2197
2198static const struct of_device_id unittest_gpio_id[] = {
2199	{ .compatible = "unittest-gpio", },
2200	{}
2201};
2202
2203static struct platform_driver unittest_gpio_driver = {
2204	.probe	= unittest_gpio_probe,
2205	.remove = unittest_gpio_remove,
2206	.driver	= {
2207		.name		= "unittest-gpio",
2208		.of_match_table	= unittest_gpio_id,
2209	},
2210};
2211
2212static void __init of_unittest_overlay_gpio(void)
2213{
2214	int chip_request_count;
2215	int probe_pass_count;
2216	int ret;
2217
2218	/*
2219	 * tests: apply overlays before registering driver
2220	 * Similar to installing a driver as a module, the
2221	 * driver is registered after applying the overlays.
2222	 *
2223	 * The overlays are applied by overlay_data_apply()
2224	 * instead of of_unittest_apply_overlay() so that they
2225	 * will not be tracked.  Thus they will not be removed
2226	 * by of_unittest_remove_tracked_overlays().
2227	 *
2228	 * - apply overlay_gpio_01
2229	 * - apply overlay_gpio_02a
2230	 * - apply overlay_gpio_02b
2231	 * - register driver
2232	 *
2233	 * register driver will result in
2234	 *   - probe and processing gpio hog for overlay_gpio_01
2235	 *   - probe for overlay_gpio_02a
2236	 *   - processing gpio for overlay_gpio_02b
2237	 */
2238
2239	probe_pass_count = unittest_gpio_probe_pass_count;
2240	chip_request_count = unittest_gpio_chip_request_count;
2241
2242	/*
2243	 * overlay_gpio_01 contains gpio node and child gpio hog node
2244	 * overlay_gpio_02a contains gpio node
2245	 * overlay_gpio_02b contains child gpio hog node
2246	 */
2247
2248	unittest(overlay_data_apply("overlay_gpio_01", NULL),
2249		 "Adding overlay 'overlay_gpio_01' failed\n");
2250
2251	unittest(overlay_data_apply("overlay_gpio_02a", NULL),
2252		 "Adding overlay 'overlay_gpio_02a' failed\n");
2253
2254	unittest(overlay_data_apply("overlay_gpio_02b", NULL),
2255		 "Adding overlay 'overlay_gpio_02b' failed\n");
2256
2257	ret = platform_driver_register(&unittest_gpio_driver);
2258	if (unittest(ret == 0, "could not register unittest gpio driver\n"))
2259		return;
2260
2261	unittest(probe_pass_count + 2 == unittest_gpio_probe_pass_count,
2262		 "unittest_gpio_probe() failed or not called\n");
2263
2264	unittest(chip_request_count + 2 == unittest_gpio_chip_request_count,
2265		 "unittest_gpio_chip_request() called %d times (expected 1 time)\n",
2266		 unittest_gpio_chip_request_count - chip_request_count);
2267
2268	/*
2269	 * tests: apply overlays after registering driver
2270	 *
2271	 * Similar to a driver built-in to the kernel, the
2272	 * driver is registered before applying the overlays.
2273	 *
2274	 * overlay_gpio_03 contains gpio node and child gpio hog node
2275	 *
2276	 * - apply overlay_gpio_03
2277	 *
2278	 * apply overlay will result in
2279	 *   - probe and processing gpio hog.
2280	 */
2281
2282	probe_pass_count = unittest_gpio_probe_pass_count;
2283	chip_request_count = unittest_gpio_chip_request_count;
2284
2285	/* overlay_gpio_03 contains gpio node and child gpio hog node */
2286
2287	unittest(overlay_data_apply("overlay_gpio_03", NULL),
2288		 "Adding overlay 'overlay_gpio_03' failed\n");
2289
2290	unittest(probe_pass_count + 1 == unittest_gpio_probe_pass_count,
2291		 "unittest_gpio_probe() failed or not called\n");
2292
2293	unittest(chip_request_count + 1 == unittest_gpio_chip_request_count,
2294		 "unittest_gpio_chip_request() called %d times (expected 1 time)\n",
2295		 unittest_gpio_chip_request_count - chip_request_count);
2296
2297	/*
2298	 * overlay_gpio_04a contains gpio node
2299	 *
2300	 * - apply overlay_gpio_04a
2301	 *
2302	 * apply the overlay will result in
2303	 *   - probe for overlay_gpio_04a
2304	 */
2305
2306	probe_pass_count = unittest_gpio_probe_pass_count;
2307	chip_request_count = unittest_gpio_chip_request_count;
2308
2309	/* overlay_gpio_04a contains gpio node */
2310
2311	unittest(overlay_data_apply("overlay_gpio_04a", NULL),
2312		 "Adding overlay 'overlay_gpio_04a' failed\n");
2313
2314	unittest(probe_pass_count + 1 == unittest_gpio_probe_pass_count,
2315		 "unittest_gpio_probe() failed or not called\n");
2316
2317	/*
2318	 * overlay_gpio_04b contains child gpio hog node
2319	 *
2320	 * - apply overlay_gpio_04b
2321	 *
2322	 * apply the overlay will result in
2323	 *   - processing gpio for overlay_gpio_04b
2324	 */
2325
2326	/* overlay_gpio_04b contains child gpio hog node */
2327
2328	unittest(overlay_data_apply("overlay_gpio_04b", NULL),
2329		 "Adding overlay 'overlay_gpio_04b' failed\n");
2330
2331	unittest(chip_request_count + 1 == unittest_gpio_chip_request_count,
2332		 "unittest_gpio_chip_request() called %d times (expected 1 time)\n",
2333		 unittest_gpio_chip_request_count - chip_request_count);
2334}
2335
2336#else
2337
2338static void __init of_unittest_overlay_gpio(void)
2339{
2340	/* skip tests */
2341}
2342
2343#endif
2344
2345#if IS_BUILTIN(CONFIG_I2C)
2346
2347/* get the i2c client device instantiated at the path */
2348static struct i2c_client *of_path_to_i2c_client(const char *path)
2349{
2350	struct device_node *np;
2351	struct i2c_client *client;
2352
2353	np = of_find_node_by_path(path);
2354	if (np == NULL)
2355		return NULL;
2356
2357	client = of_find_i2c_device_by_node(np);
2358	of_node_put(np);
2359
2360	return client;
2361}
2362
2363/* find out if a i2c client device exists at that path */
2364static int of_path_i2c_client_exists(const char *path)
2365{
2366	struct i2c_client *client;
2367
2368	client = of_path_to_i2c_client(path);
2369	if (client)
2370		put_device(&client->dev);
2371	return client != NULL;
2372}
2373#else
2374static int of_path_i2c_client_exists(const char *path)
2375{
2376	return 0;
2377}
2378#endif
2379
2380enum overlay_type {
2381	PDEV_OVERLAY,
2382	I2C_OVERLAY
2383};
2384
2385static int of_path_device_type_exists(const char *path,
2386		enum overlay_type ovtype)
2387{
2388	switch (ovtype) {
2389	case PDEV_OVERLAY:
2390		return of_path_platform_device_exists(path);
2391	case I2C_OVERLAY:
2392		return of_path_i2c_client_exists(path);
2393	}
2394	return 0;
2395}
2396
2397static const char *unittest_path(int nr, enum overlay_type ovtype)
2398{
2399	const char *base;
2400	static char buf[256];
2401
2402	switch (ovtype) {
2403	case PDEV_OVERLAY:
2404		base = "/testcase-data/overlay-node/test-bus";
2405		break;
2406	case I2C_OVERLAY:
2407		base = "/testcase-data/overlay-node/test-bus/i2c-test-bus";
2408		break;
2409	default:
2410		buf[0] = '\0';
2411		return buf;
2412	}
2413	snprintf(buf, sizeof(buf) - 1, "%s/test-unittest%d", base, nr);
2414	buf[sizeof(buf) - 1] = '\0';
2415	return buf;
2416}
2417
2418static int of_unittest_device_exists(int unittest_nr, enum overlay_type ovtype)
2419{
2420	const char *path;
2421
2422	path = unittest_path(unittest_nr, ovtype);
2423
2424	switch (ovtype) {
2425	case PDEV_OVERLAY:
2426		return of_path_platform_device_exists(path);
2427	case I2C_OVERLAY:
2428		return of_path_i2c_client_exists(path);
2429	}
2430	return 0;
2431}
2432
2433static const char *overlay_name_from_nr(int nr)
2434{
2435	static char buf[256];
2436
2437	snprintf(buf, sizeof(buf) - 1,
2438		"overlay_%d", nr);
2439	buf[sizeof(buf) - 1] = '\0';
2440
2441	return buf;
2442}
2443
2444static const char *bus_path = "/testcase-data/overlay-node/test-bus";
2445
2446#define MAX_TRACK_OVCS_IDS 256
2447
2448static int track_ovcs_id[MAX_TRACK_OVCS_IDS];
2449static int track_ovcs_id_overlay_nr[MAX_TRACK_OVCS_IDS];
2450static int track_ovcs_id_cnt;
2451
2452static void of_unittest_track_overlay(int ovcs_id, int overlay_nr)
2453{
2454	if (WARN_ON(track_ovcs_id_cnt >= MAX_TRACK_OVCS_IDS))
2455		return;
2456
2457	track_ovcs_id[track_ovcs_id_cnt] = ovcs_id;
2458	track_ovcs_id_overlay_nr[track_ovcs_id_cnt] = overlay_nr;
2459	track_ovcs_id_cnt++;
2460}
2461
2462static void of_unittest_untrack_overlay(int ovcs_id)
2463{
2464	if (WARN_ON(track_ovcs_id_cnt < 1))
2465		return;
2466
2467	track_ovcs_id_cnt--;
2468
2469	/* If out of synch then test is broken.  Do not try to recover. */
2470	WARN_ON(track_ovcs_id[track_ovcs_id_cnt] != ovcs_id);
2471}
2472
2473static void of_unittest_remove_tracked_overlays(void)
2474{
2475	int ret, ovcs_id, overlay_nr, save_ovcs_id;
2476	const char *overlay_name;
2477
2478	while (track_ovcs_id_cnt > 0) {
2479
2480		ovcs_id = track_ovcs_id[track_ovcs_id_cnt - 1];
2481		overlay_nr = track_ovcs_id_overlay_nr[track_ovcs_id_cnt - 1];
2482		save_ovcs_id = ovcs_id;
2483		ret = of_overlay_remove(&ovcs_id);
2484		if (ret == -ENODEV) {
2485			overlay_name = overlay_name_from_nr(overlay_nr);
2486			pr_warn("%s: of_overlay_remove() for overlay \"%s\" failed, ret = %d\n",
2487				__func__, overlay_name, ret);
2488		}
2489		of_unittest_untrack_overlay(save_ovcs_id);
2490	}
2491
2492}
2493
2494static int __init of_unittest_apply_overlay(int overlay_nr, int *ovcs_id)
2495{
2496	/*
2497	 * The overlay will be tracked, thus it will be removed
2498	 * by of_unittest_remove_tracked_overlays().
2499	 */
2500
2501	const char *overlay_name;
2502
2503	overlay_name = overlay_name_from_nr(overlay_nr);
2504
2505	if (!overlay_data_apply(overlay_name, ovcs_id)) {
2506		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2507		return -EFAULT;
2508	}
2509	of_unittest_track_overlay(*ovcs_id, overlay_nr);
2510
2511	return 0;
2512}
2513
2514static int __init __of_unittest_apply_overlay_check(int overlay_nr,
2515		int unittest_nr, int before, int after,
2516		enum overlay_type ovtype)
2517{
2518	int ret, ovcs_id;
2519
2520	/* unittest device must be in before state */
2521	if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
2522		unittest(0, "%s with device @\"%s\" %s\n",
2523				overlay_name_from_nr(overlay_nr),
2524				unittest_path(unittest_nr, ovtype),
2525				!before ? "enabled" : "disabled");
2526		return -EINVAL;
2527	}
2528
2529	/* apply the overlay */
2530	ovcs_id = 0;
2531	ret = of_unittest_apply_overlay(overlay_nr, &ovcs_id);
2532	if (ret != 0) {
2533		/* of_unittest_apply_overlay already called unittest() */
2534		return ret;
2535	}
2536
2537	/* unittest device must be in after state */
2538	if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
2539		unittest(0, "%s with device @\"%s\" %s\n",
2540				overlay_name_from_nr(overlay_nr),
2541				unittest_path(unittest_nr, ovtype),
2542				!after ? "enabled" : "disabled");
2543		return -EINVAL;
2544	}
2545
2546	return ovcs_id;
2547}
2548
2549/* apply an overlay while checking before and after states */
2550static int __init of_unittest_apply_overlay_check(int overlay_nr,
2551		int unittest_nr, int before, int after,
2552		enum overlay_type ovtype)
2553{
2554	int ovcs_id = __of_unittest_apply_overlay_check(overlay_nr,
2555				unittest_nr, before, after, ovtype);
2556	if (ovcs_id < 0)
2557		return ovcs_id;
2558
2559	return 0;
2560}
2561
2562/* apply an overlay and then revert it while checking before, after states */
2563static int __init of_unittest_apply_revert_overlay_check(int overlay_nr,
2564		int unittest_nr, int before, int after,
2565		enum overlay_type ovtype)
2566{
2567	int ret, ovcs_id, save_ovcs_id;
2568
2569	ovcs_id = __of_unittest_apply_overlay_check(overlay_nr, unittest_nr,
2570						    before, after, ovtype);
2571	if (ovcs_id < 0)
2572		return ovcs_id;
2573
2574	/* remove the overlay */
2575	save_ovcs_id = ovcs_id;
2576	ret = of_overlay_remove(&ovcs_id);
2577	if (ret != 0) {
2578		unittest(0, "%s failed to be destroyed @\"%s\"\n",
2579				overlay_name_from_nr(overlay_nr),
2580				unittest_path(unittest_nr, ovtype));
2581		return ret;
2582	}
2583	of_unittest_untrack_overlay(save_ovcs_id);
2584
2585	/* unittest device must be again in before state */
2586	if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
2587		unittest(0, "%s with device @\"%s\" %s\n",
2588				overlay_name_from_nr(overlay_nr),
2589				unittest_path(unittest_nr, ovtype),
2590				!before ? "enabled" : "disabled");
2591		return -EINVAL;
2592	}
2593
2594	return 0;
2595}
2596
2597/* test activation of device */
2598static void __init of_unittest_overlay_0(void)
2599{
2600	int ret;
2601
2602	EXPECT_BEGIN(KERN_INFO,
2603		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest0/status");
2604
2605	/* device should enable */
2606	ret = of_unittest_apply_overlay_check(0, 0, 0, 1, PDEV_OVERLAY);
2607
2608	EXPECT_END(KERN_INFO,
2609		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest0/status");
2610
2611	if (ret)
2612		return;
2613
2614	unittest(1, "overlay test %d passed\n", 0);
2615}
2616
2617/* test deactivation of device */
2618static void __init of_unittest_overlay_1(void)
2619{
2620	int ret;
2621
2622	EXPECT_BEGIN(KERN_INFO,
2623		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest1/status");
2624
2625	/* device should disable */
2626	ret = of_unittest_apply_overlay_check(1, 1, 1, 0, PDEV_OVERLAY);
2627
2628	EXPECT_END(KERN_INFO,
2629		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest1/status");
2630
2631	if (ret)
2632		return;
2633
2634	unittest(1, "overlay test %d passed\n", 1);
2635
2636}
2637
2638/* test activation of device */
2639static void __init of_unittest_overlay_2(void)
2640{
2641	int ret;
2642
2643	EXPECT_BEGIN(KERN_INFO,
2644		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest2/status");
2645
2646	/* device should enable */
2647	ret = of_unittest_apply_overlay_check(2, 2, 0, 1, PDEV_OVERLAY);
2648
2649	EXPECT_END(KERN_INFO,
2650		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest2/status");
2651
2652	if (ret)
2653		return;
2654	unittest(1, "overlay test %d passed\n", 2);
2655}
2656
2657/* test deactivation of device */
2658static void __init of_unittest_overlay_3(void)
2659{
2660	int ret;
2661
2662	EXPECT_BEGIN(KERN_INFO,
2663		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest3/status");
2664
2665	/* device should disable */
2666	ret = of_unittest_apply_overlay_check(3, 3, 1, 0, PDEV_OVERLAY);
2667
2668	EXPECT_END(KERN_INFO,
2669		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest3/status");
2670
2671	if (ret)
2672		return;
2673
2674	unittest(1, "overlay test %d passed\n", 3);
2675}
2676
2677/* test activation of a full device node */
2678static void __init of_unittest_overlay_4(void)
2679{
2680	/* device should disable */
2681	if (of_unittest_apply_overlay_check(4, 4, 0, 1, PDEV_OVERLAY))
2682		return;
2683
2684	unittest(1, "overlay test %d passed\n", 4);
2685}
2686
2687/* test overlay apply/revert sequence */
2688static void __init of_unittest_overlay_5(void)
2689{
2690	int ret;
2691
2692	EXPECT_BEGIN(KERN_INFO,
2693		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest5/status");
2694
2695	/* device should disable */
2696	ret = of_unittest_apply_revert_overlay_check(5, 5, 0, 1, PDEV_OVERLAY);
2697
2698	EXPECT_END(KERN_INFO,
2699		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest5/status");
2700
2701	if (ret)
2702		return;
2703
2704	unittest(1, "overlay test %d passed\n", 5);
2705}
2706
2707/* test overlay application in sequence */
2708static void __init of_unittest_overlay_6(void)
2709{
2710	int i, save_ovcs_id[2], ovcs_id;
2711	int overlay_nr = 6, unittest_nr = 6;
2712	int before = 0, after = 1;
2713	const char *overlay_name;
2714
2715	int ret;
2716
2717	/* unittest device must be in before state */
2718	for (i = 0; i < 2; i++) {
2719		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
2720				!= before) {
2721			unittest(0, "%s with device @\"%s\" %s\n",
2722					overlay_name_from_nr(overlay_nr + i),
2723					unittest_path(unittest_nr + i,
2724						PDEV_OVERLAY),
2725					!before ? "enabled" : "disabled");
2726			return;
2727		}
2728	}
2729
2730	/* apply the overlays */
2731
2732	EXPECT_BEGIN(KERN_INFO,
2733		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest6/status");
2734
2735	overlay_name = overlay_name_from_nr(overlay_nr + 0);
2736
2737	ret = overlay_data_apply(overlay_name, &ovcs_id);
2738
2739	if (!ret) {
2740		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2741			return;
2742	}
2743	save_ovcs_id[0] = ovcs_id;
2744	of_unittest_track_overlay(ovcs_id, overlay_nr + 0);
2745
2746	EXPECT_END(KERN_INFO,
2747		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest6/status");
2748
2749	EXPECT_BEGIN(KERN_INFO,
2750		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest7/status");
2751
2752	overlay_name = overlay_name_from_nr(overlay_nr + 1);
2753
2754	ret = overlay_data_apply(overlay_name, &ovcs_id);
2755
2756	if (!ret) {
2757		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2758			return;
2759	}
2760	save_ovcs_id[1] = ovcs_id;
2761	of_unittest_track_overlay(ovcs_id, overlay_nr + 1);
2762
2763	EXPECT_END(KERN_INFO,
2764		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest7/status");
2765
2766
2767	for (i = 0; i < 2; i++) {
2768		/* unittest device must be in after state */
2769		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
2770				!= after) {
2771			unittest(0, "overlay @\"%s\" failed @\"%s\" %s\n",
2772					overlay_name_from_nr(overlay_nr + i),
2773					unittest_path(unittest_nr + i,
2774						PDEV_OVERLAY),
2775					!after ? "enabled" : "disabled");
2776			return;
2777		}
2778	}
2779
2780	for (i = 1; i >= 0; i--) {
2781		ovcs_id = save_ovcs_id[i];
2782		if (of_overlay_remove(&ovcs_id)) {
2783			unittest(0, "%s failed destroy @\"%s\"\n",
2784					overlay_name_from_nr(overlay_nr + i),
2785					unittest_path(unittest_nr + i,
2786						PDEV_OVERLAY));
2787			return;
2788		}
2789		of_unittest_untrack_overlay(save_ovcs_id[i]);
2790	}
2791
2792	for (i = 0; i < 2; i++) {
2793		/* unittest device must be again in before state */
2794		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
2795				!= before) {
2796			unittest(0, "%s with device @\"%s\" %s\n",
2797					overlay_name_from_nr(overlay_nr + i),
2798					unittest_path(unittest_nr + i,
2799						PDEV_OVERLAY),
2800					!before ? "enabled" : "disabled");
2801			return;
2802		}
2803	}
2804
2805	unittest(1, "overlay test %d passed\n", 6);
2806
2807}
2808
2809/* test overlay application in sequence */
2810static void __init of_unittest_overlay_8(void)
2811{
2812	int i, save_ovcs_id[2], ovcs_id;
2813	int overlay_nr = 8, unittest_nr = 8;
2814	const char *overlay_name;
2815	int ret;
2816
2817	/* we don't care about device state in this test */
2818
2819	EXPECT_BEGIN(KERN_INFO,
2820		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/status");
2821
2822	overlay_name = overlay_name_from_nr(overlay_nr + 0);
2823
2824	ret = overlay_data_apply(overlay_name, &ovcs_id);
2825	if (!ret)
2826		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2827
2828	EXPECT_END(KERN_INFO,
2829		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/status");
2830
2831	if (!ret)
2832		return;
2833
2834	save_ovcs_id[0] = ovcs_id;
2835	of_unittest_track_overlay(ovcs_id, overlay_nr + 0);
2836
2837	overlay_name = overlay_name_from_nr(overlay_nr + 1);
2838
2839	EXPECT_BEGIN(KERN_INFO,
2840		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/property-foo");
2841
2842	/* apply the overlays */
2843	ret = overlay_data_apply(overlay_name, &ovcs_id);
2844
2845	EXPECT_END(KERN_INFO,
2846		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/property-foo");
2847
2848	if (!ret) {
2849		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2850		return;
2851	}
2852
2853	save_ovcs_id[1] = ovcs_id;
2854	of_unittest_track_overlay(ovcs_id, overlay_nr + 1);
2855
2856	/* now try to remove first overlay (it should fail) */
2857	ovcs_id = save_ovcs_id[0];
2858
2859	EXPECT_BEGIN(KERN_INFO,
2860		     "OF: overlay: node_overlaps_later_cs: #6 overlaps with #7 @/testcase-data/overlay-node/test-bus/test-unittest8");
2861
2862	EXPECT_BEGIN(KERN_INFO,
2863		     "OF: overlay: overlay #6 is not topmost");
2864
2865	ret = of_overlay_remove(&ovcs_id);
2866
2867	EXPECT_END(KERN_INFO,
2868		   "OF: overlay: overlay #6 is not topmost");
2869
2870	EXPECT_END(KERN_INFO,
2871		   "OF: overlay: node_overlaps_later_cs: #6 overlaps with #7 @/testcase-data/overlay-node/test-bus/test-unittest8");
2872
2873	if (!ret) {
2874		/*
2875		 * Should never get here.  If we do, expect a lot of
2876		 * subsequent tracking and overlay removal related errors.
2877		 */
2878		unittest(0, "%s was destroyed @\"%s\"\n",
2879				overlay_name_from_nr(overlay_nr + 0),
2880				unittest_path(unittest_nr,
2881					PDEV_OVERLAY));
2882		return;
2883	}
2884
2885	/* removing them in order should work */
2886	for (i = 1; i >= 0; i--) {
2887		ovcs_id = save_ovcs_id[i];
2888		if (of_overlay_remove(&ovcs_id)) {
2889			unittest(0, "%s not destroyed @\"%s\"\n",
2890					overlay_name_from_nr(overlay_nr + i),
2891					unittest_path(unittest_nr,
2892						PDEV_OVERLAY));
2893			return;
2894		}
2895		of_unittest_untrack_overlay(save_ovcs_id[i]);
2896	}
2897
2898	unittest(1, "overlay test %d passed\n", 8);
2899}
2900
2901/* test insertion of a bus with parent devices */
2902static void __init of_unittest_overlay_10(void)
2903{
2904	int ret;
2905	char *child_path;
2906
2907	/* device should disable */
2908	ret = of_unittest_apply_overlay_check(10, 10, 0, 1, PDEV_OVERLAY);
2909
2910	if (unittest(ret == 0,
2911			"overlay test %d failed; overlay application\n", 10))
2912		return;
2913
2914	child_path = kasprintf(GFP_KERNEL, "%s/test-unittest101",
2915			unittest_path(10, PDEV_OVERLAY));
2916	if (unittest(child_path, "overlay test %d failed; kasprintf\n", 10))
2917		return;
2918
2919	ret = of_path_device_type_exists(child_path, PDEV_OVERLAY);
2920	kfree(child_path);
2921
2922	unittest(ret, "overlay test %d failed; no child device\n", 10);
2923}
2924
2925/* test insertion of a bus with parent devices (and revert) */
2926static void __init of_unittest_overlay_11(void)
2927{
2928	int ret;
2929
2930	/* device should disable */
2931	ret = of_unittest_apply_revert_overlay_check(11, 11, 0, 1,
2932			PDEV_OVERLAY);
2933
2934	unittest(ret == 0, "overlay test %d failed; overlay apply\n", 11);
2935}
2936
2937#if IS_BUILTIN(CONFIG_I2C) && IS_ENABLED(CONFIG_OF_OVERLAY)
2938
2939struct unittest_i2c_bus_data {
2940	struct platform_device	*pdev;
2941	struct i2c_adapter	adap;
2942};
2943
2944static int unittest_i2c_master_xfer(struct i2c_adapter *adap,
2945		struct i2c_msg *msgs, int num)
2946{
2947	struct unittest_i2c_bus_data *std = i2c_get_adapdata(adap);
2948
2949	(void)std;
2950
2951	return num;
2952}
2953
2954static u32 unittest_i2c_functionality(struct i2c_adapter *adap)
2955{
2956	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
2957}
2958
2959static const struct i2c_algorithm unittest_i2c_algo = {
2960	.master_xfer	= unittest_i2c_master_xfer,
2961	.functionality	= unittest_i2c_functionality,
2962};
2963
2964static int unittest_i2c_bus_probe(struct platform_device *pdev)
2965{
2966	struct device *dev = &pdev->dev;
2967	struct device_node *np = dev->of_node;
2968	struct unittest_i2c_bus_data *std;
2969	struct i2c_adapter *adap;
2970	int ret;
2971
2972	if (np == NULL) {
2973		dev_err(dev, "No OF data for device\n");
2974		return -EINVAL;
2975
2976	}
2977
2978	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2979
2980	std = devm_kzalloc(dev, sizeof(*std), GFP_KERNEL);
2981	if (!std)
2982		return -ENOMEM;
2983
2984	/* link them together */
2985	std->pdev = pdev;
2986	platform_set_drvdata(pdev, std);
2987
2988	adap = &std->adap;
2989	i2c_set_adapdata(adap, std);
2990	adap->nr = -1;
2991	strscpy(adap->name, pdev->name, sizeof(adap->name));
2992	adap->class = I2C_CLASS_DEPRECATED;
2993	adap->algo = &unittest_i2c_algo;
2994	adap->dev.parent = dev;
2995	adap->dev.of_node = dev->of_node;
2996	adap->timeout = 5 * HZ;
2997	adap->retries = 3;
2998
2999	ret = i2c_add_numbered_adapter(adap);
3000	if (ret != 0) {
3001		dev_err(dev, "Failed to add I2C adapter\n");
3002		return ret;
3003	}
3004
3005	return 0;
3006}
3007
3008static void unittest_i2c_bus_remove(struct platform_device *pdev)
3009{
3010	struct device *dev = &pdev->dev;
3011	struct device_node *np = dev->of_node;
3012	struct unittest_i2c_bus_data *std = platform_get_drvdata(pdev);
3013
3014	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
3015	i2c_del_adapter(&std->adap);
3016}
3017
3018static const struct of_device_id unittest_i2c_bus_match[] = {
3019	{ .compatible = "unittest-i2c-bus", },
3020	{},
3021};
3022
3023static struct platform_driver unittest_i2c_bus_driver = {
3024	.probe			= unittest_i2c_bus_probe,
3025	.remove			= unittest_i2c_bus_remove,
3026	.driver = {
3027		.name		= "unittest-i2c-bus",
3028		.of_match_table	= unittest_i2c_bus_match,
3029	},
3030};
3031
3032static int unittest_i2c_dev_probe(struct i2c_client *client)
3033{
3034	struct device *dev = &client->dev;
3035	struct device_node *np = client->dev.of_node;
3036
3037	if (!np) {
3038		dev_err(dev, "No OF node\n");
3039		return -EINVAL;
3040	}
3041
3042	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
3043
3044	return 0;
3045};
3046
3047static void unittest_i2c_dev_remove(struct i2c_client *client)
3048{
3049	struct device *dev = &client->dev;
3050	struct device_node *np = client->dev.of_node;
3051
3052	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
3053}
3054
3055static const struct i2c_device_id unittest_i2c_dev_id[] = {
3056	{ .name = "unittest-i2c-dev" },
3057	{ }
3058};
3059
3060static struct i2c_driver unittest_i2c_dev_driver = {
3061	.driver = {
3062		.name = "unittest-i2c-dev",
3063	},
3064	.probe = unittest_i2c_dev_probe,
3065	.remove = unittest_i2c_dev_remove,
3066	.id_table = unittest_i2c_dev_id,
3067};
3068
3069#if IS_BUILTIN(CONFIG_I2C_MUX)
3070
3071static int unittest_i2c_mux_select_chan(struct i2c_mux_core *muxc, u32 chan)
3072{
3073	return 0;
3074}
3075
3076static int unittest_i2c_mux_probe(struct i2c_client *client)
3077{
3078	int i, nchans;
3079	struct device *dev = &client->dev;
3080	struct i2c_adapter *adap = client->adapter;
3081	struct device_node *np = client->dev.of_node, *child;
3082	struct i2c_mux_core *muxc;
3083	u32 reg, max_reg;
3084
3085	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
3086
3087	if (!np) {
3088		dev_err(dev, "No OF node\n");
3089		return -EINVAL;
3090	}
3091
3092	max_reg = (u32)-1;
3093	for_each_child_of_node(np, child) {
3094		if (of_property_read_u32(child, "reg", &reg))
3095			continue;
3096		if (max_reg == (u32)-1 || reg > max_reg)
3097			max_reg = reg;
3098	}
3099	nchans = max_reg == (u32)-1 ? 0 : max_reg + 1;
3100	if (nchans == 0) {
3101		dev_err(dev, "No channels\n");
3102		return -EINVAL;
3103	}
3104
3105	muxc = i2c_mux_alloc(adap, dev, nchans, 0, 0,
3106			     unittest_i2c_mux_select_chan, NULL);
3107	if (!muxc)
3108		return -ENOMEM;
3109	for (i = 0; i < nchans; i++) {
3110		if (i2c_mux_add_adapter(muxc, 0, i)) {
3111			dev_err(dev, "Failed to register mux #%d\n", i);
3112			i2c_mux_del_adapters(muxc);
3113			return -ENODEV;
3114		}
3115	}
3116
3117	i2c_set_clientdata(client, muxc);
3118
3119	return 0;
3120};
3121
3122static void unittest_i2c_mux_remove(struct i2c_client *client)
3123{
3124	struct device *dev = &client->dev;
3125	struct device_node *np = client->dev.of_node;
3126	struct i2c_mux_core *muxc = i2c_get_clientdata(client);
3127
3128	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
3129	i2c_mux_del_adapters(muxc);
3130}
3131
3132static const struct i2c_device_id unittest_i2c_mux_id[] = {
3133	{ .name = "unittest-i2c-mux" },
3134	{ }
3135};
3136
3137static struct i2c_driver unittest_i2c_mux_driver = {
3138	.driver = {
3139		.name = "unittest-i2c-mux",
3140	},
3141	.probe = unittest_i2c_mux_probe,
3142	.remove = unittest_i2c_mux_remove,
3143	.id_table = unittest_i2c_mux_id,
3144};
3145
3146#endif
3147
3148static int of_unittest_overlay_i2c_init(void)
3149{
3150	int ret;
3151
3152	ret = i2c_add_driver(&unittest_i2c_dev_driver);
3153	if (unittest(ret == 0,
3154			"could not register unittest i2c device driver\n"))
3155		return ret;
3156
3157	ret = platform_driver_register(&unittest_i2c_bus_driver);
3158
3159	if (unittest(ret == 0,
3160			"could not register unittest i2c bus driver\n"))
3161		return ret;
3162
3163#if IS_BUILTIN(CONFIG_I2C_MUX)
3164
3165	EXPECT_BEGIN(KERN_INFO,
3166		     "i2c i2c-1: Added multiplexed i2c bus 2");
3167
3168	ret = i2c_add_driver(&unittest_i2c_mux_driver);
3169
3170	EXPECT_END(KERN_INFO,
3171		   "i2c i2c-1: Added multiplexed i2c bus 2");
3172
3173	if (unittest(ret == 0,
3174			"could not register unittest i2c mux driver\n"))
3175		return ret;
3176#endif
3177
3178	return 0;
3179}
3180
3181static void of_unittest_overlay_i2c_cleanup(void)
3182{
3183#if IS_BUILTIN(CONFIG_I2C_MUX)
3184	i2c_del_driver(&unittest_i2c_mux_driver);
3185#endif
3186	platform_driver_unregister(&unittest_i2c_bus_driver);
3187	i2c_del_driver(&unittest_i2c_dev_driver);
3188}
3189
3190static void __init of_unittest_overlay_i2c_12(void)
3191{
3192	int ret;
3193
3194	/* device should enable */
3195	EXPECT_BEGIN(KERN_INFO,
3196		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest12/status");
3197
3198	ret = of_unittest_apply_overlay_check(12, 12, 0, 1, I2C_OVERLAY);
3199
3200	EXPECT_END(KERN_INFO,
3201		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest12/status");
3202
3203	if (ret)
3204		return;
3205
3206	unittest(1, "overlay test %d passed\n", 12);
3207}
3208
3209/* test deactivation of device */
3210static void __init of_unittest_overlay_i2c_13(void)
3211{
3212	int ret;
3213
3214	EXPECT_BEGIN(KERN_INFO,
3215		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest13/status");
3216
3217	/* device should disable */
3218	ret = of_unittest_apply_overlay_check(13, 13, 1, 0, I2C_OVERLAY);
3219
3220	EXPECT_END(KERN_INFO,
3221		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest13/status");
3222
3223	if (ret)
3224		return;
3225
3226	unittest(1, "overlay test %d passed\n", 13);
3227}
3228
3229/* just check for i2c mux existence */
3230static void of_unittest_overlay_i2c_14(void)
3231{
3232}
3233
3234static void __init of_unittest_overlay_i2c_15(void)
3235{
3236	int ret;
3237
3238	/* device should enable */
3239	EXPECT_BEGIN(KERN_INFO,
3240		     "i2c i2c-1: Added multiplexed i2c bus 3");
3241
3242	ret = of_unittest_apply_overlay_check(15, 15, 0, 1, I2C_OVERLAY);
3243
3244	EXPECT_END(KERN_INFO,
3245		   "i2c i2c-1: Added multiplexed i2c bus 3");
3246
3247	if (ret)
3248		return;
3249
3250	unittest(1, "overlay test %d passed\n", 15);
3251}
3252
3253#else
3254
3255static inline void of_unittest_overlay_i2c_14(void) { }
3256static inline void of_unittest_overlay_i2c_15(void) { }
3257
3258#endif
3259
3260static int of_notify(struct notifier_block *nb, unsigned long action,
3261		     void *arg)
3262{
3263	struct of_overlay_notify_data *nd = arg;
3264	struct device_node *found;
3265	int ret;
3266
3267	/*
3268	 * For overlay_16 .. overlay_19, check that returning an error
3269	 * works for each of the actions by setting an arbitrary return
3270	 * error number that matches the test number.  e.g. for unittest16,
3271	 * ret = -EBUSY which is -16.
3272	 *
3273	 * OVERLAY_INFO() for the overlays is declared to expect the same
3274	 * error number, so overlay_data_apply() will return no error.
3275	 *
3276	 * overlay_20 will return NOTIFY_DONE
3277	 */
3278
3279	ret = 0;
3280	of_node_get(nd->overlay);
3281
3282	switch (action) {
3283
3284	case OF_OVERLAY_PRE_APPLY:
3285		found = of_find_node_by_name(nd->overlay, "test-unittest16");
3286		if (found) {
3287			of_node_put(found);
3288			ret = -EBUSY;
3289		}
3290		break;
3291
3292	case OF_OVERLAY_POST_APPLY:
3293		found = of_find_node_by_name(nd->overlay, "test-unittest17");
3294		if (found) {
3295			of_node_put(found);
3296			ret = -EEXIST;
3297		}
3298		break;
3299
3300	case OF_OVERLAY_PRE_REMOVE:
3301		found = of_find_node_by_name(nd->overlay, "test-unittest18");
3302		if (found) {
3303			of_node_put(found);
3304			ret = -EXDEV;
3305		}
3306		break;
3307
3308	case OF_OVERLAY_POST_REMOVE:
3309		found = of_find_node_by_name(nd->overlay, "test-unittest19");
3310		if (found) {
3311			of_node_put(found);
3312			ret = -ENODEV;
3313		}
3314		break;
3315
3316	default:			/* should not happen */
3317		of_node_put(nd->overlay);
3318		ret = -EINVAL;
3319		break;
3320	}
3321
3322	if (ret)
3323		return notifier_from_errno(ret);
3324
3325	return NOTIFY_DONE;
3326}
3327
3328static struct notifier_block of_nb = {
3329	.notifier_call = of_notify,
3330};
3331
3332static void __init of_unittest_overlay_notify(void)
3333{
3334	int ovcs_id;
3335	int ret;
3336
3337	ret = of_overlay_notifier_register(&of_nb);
3338	unittest(!ret,
3339		 "of_overlay_notifier_register() failed, ret = %d\n", ret);
3340	if (ret)
3341		return;
3342
3343	/*
3344	 * The overlays are applied by overlay_data_apply()
3345	 * instead of of_unittest_apply_overlay() so that they
3346	 * will not be tracked.  Thus they will not be removed
3347	 * by of_unittest_remove_tracked_overlays().
3348	 *
3349	 * Applying overlays 16 - 19 will each trigger an error for a
3350	 * different action in of_notify().
3351	 *
3352	 * Applying overlay 20 will not trigger any error in of_notify().
3353	 */
3354
3355	/* ---  overlay 16  --- */
3356
3357	EXPECT_BEGIN(KERN_INFO, "OF: overlay: overlay changeset pre-apply notifier error -16, target: /testcase-data/overlay-node/test-bus");
3358
3359	unittest(overlay_data_apply("overlay_16", &ovcs_id),
3360		 "test OF_OVERLAY_PRE_APPLY notify injected error\n");
3361
3362	EXPECT_END(KERN_INFO, "OF: overlay: overlay changeset pre-apply notifier error -16, target: /testcase-data/overlay-node/test-bus");
3363
3364	unittest(ovcs_id, "ovcs_id not created for overlay_16\n");
3365
3366	/* ---  overlay 17  --- */
3367
3368	EXPECT_BEGIN(KERN_INFO, "OF: overlay: overlay changeset post-apply notifier error -17, target: /testcase-data/overlay-node/test-bus");
3369
3370	unittest(overlay_data_apply("overlay_17", &ovcs_id),
3371		 "test OF_OVERLAY_POST_APPLY notify injected error\n");
3372
3373	EXPECT_END(KERN_INFO, "OF: overlay: overlay changeset post-apply notifier error -17, target: /testcase-data/overlay-node/test-bus");
3374
3375	unittest(ovcs_id, "ovcs_id not created for overlay_17\n");
3376
3377	/* ---  overlay 18  --- */
3378
3379	unittest(overlay_data_apply("overlay_18", &ovcs_id),
3380		 "OF_OVERLAY_PRE_REMOVE notify injected error\n");
3381
3382	unittest(ovcs_id, "ovcs_id not created for overlay_18\n");
3383
3384	if (ovcs_id) {
3385		EXPECT_BEGIN(KERN_INFO, "OF: overlay: overlay changeset pre-remove notifier error -18, target: /testcase-data/overlay-node/test-bus");
3386
3387		ret = of_overlay_remove(&ovcs_id);
3388		EXPECT_END(KERN_INFO, "OF: overlay: overlay changeset pre-remove notifier error -18, target: /testcase-data/overlay-node/test-bus");
3389		if (ret == -EXDEV) {
3390			/*
3391			 * change set ovcs_id should still exist
3392			 */
3393			unittest(1, "overlay_18 of_overlay_remove() injected error for OF_OVERLAY_PRE_REMOVE\n");
3394		} else {
3395			unittest(0, "overlay_18 of_overlay_remove() injected error for OF_OVERLAY_PRE_REMOVE not returned\n");
3396		}
3397	} else {
3398		unittest(1, "ovcs_id not created for overlay_18\n");
3399	}
3400
3401	unittest(ovcs_id, "ovcs_id removed for overlay_18\n");
3402
3403	/* ---  overlay 19  --- */
3404
3405	unittest(overlay_data_apply("overlay_19", &ovcs_id),
3406		 "OF_OVERLAY_POST_REMOVE notify injected error\n");
3407
3408	unittest(ovcs_id, "ovcs_id not created for overlay_19\n");
3409
3410	if (ovcs_id) {
3411		EXPECT_BEGIN(KERN_INFO, "OF: overlay: overlay changeset post-remove notifier error -19, target: /testcase-data/overlay-node/test-bus");
3412		ret = of_overlay_remove(&ovcs_id);
3413		EXPECT_END(KERN_INFO, "OF: overlay: overlay changeset post-remove notifier error -19, target: /testcase-data/overlay-node/test-bus");
3414		if (ret == -ENODEV)
3415			unittest(1, "overlay_19 of_overlay_remove() injected error for OF_OVERLAY_POST_REMOVE\n");
3416		else
3417			unittest(0, "overlay_19 of_overlay_remove() injected error for OF_OVERLAY_POST_REMOVE not returned\n");
3418	} else {
3419		unittest(1, "ovcs_id removed for overlay_19\n");
3420	}
3421
3422	unittest(!ovcs_id, "changeset ovcs_id = %d not removed for overlay_19\n",
3423		 ovcs_id);
3424
3425	/* ---  overlay 20  --- */
3426
3427	unittest(overlay_data_apply("overlay_20", &ovcs_id),
3428		 "overlay notify no injected error\n");
3429
3430	if (ovcs_id) {
3431		ret = of_overlay_remove(&ovcs_id);
3432		if (ret)
3433			unittest(1, "overlay_20 failed to be destroyed, ret = %d\n",
3434				 ret);
3435	} else {
3436		unittest(1, "ovcs_id not created for overlay_20\n");
3437	}
3438
3439	unittest(!of_overlay_notifier_unregister(&of_nb),
3440		 "of_overlay_notifier_unregister() failed, ret = %d\n", ret);
3441}
3442
3443static void __init of_unittest_overlay(void)
3444{
3445	struct device_node *bus_np = NULL;
3446	unsigned int i;
3447
3448	if (platform_driver_register(&unittest_driver)) {
3449		unittest(0, "could not register unittest driver\n");
3450		goto out;
3451	}
3452
3453	bus_np = of_find_node_by_path(bus_path);
3454	if (bus_np == NULL) {
3455		unittest(0, "could not find bus_path \"%s\"\n", bus_path);
3456		goto out;
3457	}
3458
3459	if (of_platform_default_populate(bus_np, NULL, NULL)) {
3460		unittest(0, "could not populate bus @ \"%s\"\n", bus_path);
3461		goto out;
3462	}
3463
3464	if (!of_unittest_device_exists(100, PDEV_OVERLAY)) {
3465		unittest(0, "could not find unittest0 @ \"%s\"\n",
3466				unittest_path(100, PDEV_OVERLAY));
3467		goto out;
3468	}
3469
3470	if (of_unittest_device_exists(101, PDEV_OVERLAY)) {
3471		unittest(0, "unittest1 @ \"%s\" should not exist\n",
3472				unittest_path(101, PDEV_OVERLAY));
3473		goto out;
3474	}
3475
3476	unittest(1, "basic infrastructure of overlays passed");
3477
3478	/* tests in sequence */
3479	of_unittest_overlay_0();
3480	of_unittest_overlay_1();
3481	of_unittest_overlay_2();
3482	of_unittest_overlay_3();
3483	of_unittest_overlay_4();
3484	for (i = 0; i < 3; i++)
3485		of_unittest_overlay_5();
3486	of_unittest_overlay_6();
3487	of_unittest_overlay_8();
3488
3489	of_unittest_overlay_10();
3490	of_unittest_overlay_11();
3491
3492#if IS_BUILTIN(CONFIG_I2C)
3493	if (unittest(of_unittest_overlay_i2c_init() == 0, "i2c init failed\n"))
3494		goto out;
3495
3496	of_unittest_overlay_i2c_12();
3497	of_unittest_overlay_i2c_13();
3498	of_unittest_overlay_i2c_14();
3499	of_unittest_overlay_i2c_15();
3500
3501	of_unittest_overlay_i2c_cleanup();
3502#endif
3503
3504	of_unittest_overlay_gpio();
3505
3506	of_unittest_remove_tracked_overlays();
3507
3508	of_unittest_overlay_notify();
3509
3510out:
3511	of_node_put(bus_np);
3512}
3513
3514#else
3515static inline void __init of_unittest_overlay(void) { }
3516#endif
3517
3518static void __init of_unittest_lifecycle(void)
3519{
3520#ifdef CONFIG_OF_DYNAMIC
3521	unsigned int refcount;
3522	int found_refcount_one = 0;
3523	int put_count = 0;
3524	struct device_node *np;
3525	struct device_node *prev_sibling, *next_sibling;
3526	const char *refcount_path = "/testcase-data/refcount-node";
3527	const char *refcount_parent_path = "/testcase-data";
3528
3529	/*
3530	 * Node lifecycle tests, non-dynamic node:
3531	 *
3532	 * - Decrementing refcount to zero via of_node_put() should cause the
3533	 *   attempt to free the node memory by of_node_release() to fail
3534	 *   because the node is not a dynamic node.
3535	 *
3536	 * - Decrementing refcount past zero should result in additional
3537	 *   errors reported.
3538	 */
3539
3540	np = of_find_node_by_path(refcount_path);
3541	unittest(np, "find refcount_path \"%s\"\n", refcount_path);
3542	if (np == NULL)
3543		goto out_skip_tests;
3544
3545	while (!found_refcount_one) {
3546
3547		if (put_count++ > 10) {
3548			unittest(0, "guardrail to avoid infinite loop\n");
3549			goto out_skip_tests;
3550		}
3551
3552		refcount = kref_read(&np->kobj.kref);
3553		if (refcount == 1)
3554			found_refcount_one = 1;
3555		else
3556			of_node_put(np);
3557	}
3558
3559	EXPECT_BEGIN(KERN_INFO, "OF: ERROR: of_node_release() detected bad of_node_put() on /testcase-data/refcount-node");
3560
3561	/*
3562	 * refcount is now one, decrementing to zero will result in a call to
3563	 * of_node_release() to free the node's memory, which should result
3564	 * in an error
3565	 */
3566	unittest(1, "/testcase-data/refcount-node is one");
3567	of_node_put(np);
3568
3569	EXPECT_END(KERN_INFO, "OF: ERROR: of_node_release() detected bad of_node_put() on /testcase-data/refcount-node");
3570
3571
3572	/*
3573	 * expect stack trace for subsequent of_node_put():
3574	 *   __refcount_sub_and_test() calls:
3575	 *   refcount_warn_saturate(r, REFCOUNT_SUB_UAF)
3576	 *
3577	 * Not capturing entire WARN_ONCE() trace with EXPECT_*(), just
3578	 * the first three lines, and the last line.
3579	 */
3580	EXPECT_BEGIN(KERN_INFO, "------------[ cut here ]------------");
3581	EXPECT_BEGIN(KERN_INFO, "WARNING: <<all>>");
3582	EXPECT_BEGIN(KERN_INFO, "refcount_t: underflow; use-after-free.");
3583	EXPECT_BEGIN(KERN_INFO, "---[ end trace <<int>> ]---");
3584
3585	/* refcount is now zero, this should fail */
3586	unittest(1, "/testcase-data/refcount-node is zero");
3587	of_node_put(np);
3588
3589	EXPECT_END(KERN_INFO, "---[ end trace <<int>> ]---");
3590	EXPECT_END(KERN_INFO, "refcount_t: underflow; use-after-free.");
3591	EXPECT_END(KERN_INFO, "WARNING: <<all>>");
3592	EXPECT_END(KERN_INFO, "------------[ cut here ]------------");
3593
3594	/*
3595	 * Q. do we expect to get yet another warning?
3596	 * A. no, the WARNING is from WARN_ONCE()
3597	 */
3598	EXPECT_NOT_BEGIN(KERN_INFO, "------------[ cut here ]------------");
3599	EXPECT_NOT_BEGIN(KERN_INFO, "WARNING: <<all>>");
3600	EXPECT_NOT_BEGIN(KERN_INFO, "refcount_t: underflow; use-after-free.");
3601	EXPECT_NOT_BEGIN(KERN_INFO, "---[ end trace <<int>> ]---");
3602
3603	unittest(1, "/testcase-data/refcount-node is zero, second time");
3604	of_node_put(np);
3605
3606	EXPECT_NOT_END(KERN_INFO, "---[ end trace <<int>> ]---");
3607	EXPECT_NOT_END(KERN_INFO, "refcount_t: underflow; use-after-free.");
3608	EXPECT_NOT_END(KERN_INFO, "WARNING: <<all>>");
3609	EXPECT_NOT_END(KERN_INFO, "------------[ cut here ]------------");
3610
3611	/*
3612	 * refcount of zero will trigger stack traces from any further
3613	 * attempt to of_node_get() node "refcount-node". One example of
3614	 * this is where of_unittest_check_node_linkage() will recursively
3615	 * scan the tree, with 'for_each_child_of_node()' doing an
3616	 * of_node_get() of the children of a node.
3617	 *
3618	 * Prevent the stack trace by removing node "refcount-node" from
3619	 * its parent's child list.
3620	 *
3621	 * WARNING:  EVIL, EVIL, EVIL:
3622	 *
3623	 *   Directly manipulate the child list of node /testcase-data to
3624	 *   remove child refcount-node.  This is ignoring all proper methods
3625	 *   of removing a child and will leak a small amount of memory.
3626	 */
3627
3628	np = of_find_node_by_path(refcount_parent_path);
3629	unittest(np, "find refcount_parent_path \"%s\"\n", refcount_parent_path);
3630	unittest(np, "ERROR: devicetree live tree left in a 'bad state' if test fail\n");
3631	if (np == NULL)
3632		return;
3633
3634	prev_sibling = np->child;
3635	next_sibling = prev_sibling->sibling;
3636	if (!strcmp(prev_sibling->full_name, "refcount-node")) {
3637		np->child = next_sibling;
3638		next_sibling = next_sibling->sibling;
3639	}
3640	while (next_sibling) {
3641		if (!strcmp(next_sibling->full_name, "refcount-node"))
3642			prev_sibling->sibling = next_sibling->sibling;
3643		prev_sibling = next_sibling;
3644		next_sibling = next_sibling->sibling;
3645	}
3646	of_node_put(np);
3647
3648	return;
3649
3650out_skip_tests:
3651#endif
3652	unittest(0, "One or more lifecycle tests skipped\n");
3653}
3654
3655#ifdef CONFIG_OF_OVERLAY
3656
3657/*
3658 * __dtbo_##overlay_name##_begin[] and __dtbo_##overlay_name##_end[] are
3659 * created by cmd_wrap_S_dtbo in scripts/Makefile.dtbs
3660 */
3661
3662#define OVERLAY_INFO_EXTERN(overlay_name) \
3663	extern uint8_t __dtbo_##overlay_name##_begin[]; \
3664	extern uint8_t __dtbo_##overlay_name##_end[]
3665
3666#define OVERLAY_INFO(overlay_name, expected, expected_remove) \
3667{	.dtbo_begin		= __dtbo_##overlay_name##_begin, \
3668	.dtbo_end		= __dtbo_##overlay_name##_end, \
3669	.expected_result	= expected, \
3670	.expected_result_remove	= expected_remove, \
3671	.name			= #overlay_name, \
3672}
3673
3674struct overlay_info {
3675	uint8_t		*dtbo_begin;
3676	uint8_t		*dtbo_end;
3677	int		expected_result;
3678	int		expected_result_remove;	/* if apply failed */
3679	int		ovcs_id;
3680	char		*name;
3681};
3682
3683OVERLAY_INFO_EXTERN(overlay_base);
3684OVERLAY_INFO_EXTERN(overlay);
3685OVERLAY_INFO_EXTERN(overlay_0);
3686OVERLAY_INFO_EXTERN(overlay_1);
3687OVERLAY_INFO_EXTERN(overlay_2);
3688OVERLAY_INFO_EXTERN(overlay_3);
3689OVERLAY_INFO_EXTERN(overlay_4);
3690OVERLAY_INFO_EXTERN(overlay_5);
3691OVERLAY_INFO_EXTERN(overlay_6);
3692OVERLAY_INFO_EXTERN(overlay_7);
3693OVERLAY_INFO_EXTERN(overlay_8);
3694OVERLAY_INFO_EXTERN(overlay_9);
3695OVERLAY_INFO_EXTERN(overlay_10);
3696OVERLAY_INFO_EXTERN(overlay_11);
3697OVERLAY_INFO_EXTERN(overlay_12);
3698OVERLAY_INFO_EXTERN(overlay_13);
3699OVERLAY_INFO_EXTERN(overlay_15);
3700OVERLAY_INFO_EXTERN(overlay_16);
3701OVERLAY_INFO_EXTERN(overlay_17);
3702OVERLAY_INFO_EXTERN(overlay_18);
3703OVERLAY_INFO_EXTERN(overlay_19);
3704OVERLAY_INFO_EXTERN(overlay_20);
3705OVERLAY_INFO_EXTERN(overlay_gpio_01);
3706OVERLAY_INFO_EXTERN(overlay_gpio_02a);
3707OVERLAY_INFO_EXTERN(overlay_gpio_02b);
3708OVERLAY_INFO_EXTERN(overlay_gpio_03);
3709OVERLAY_INFO_EXTERN(overlay_gpio_04a);
3710OVERLAY_INFO_EXTERN(overlay_gpio_04b);
3711OVERLAY_INFO_EXTERN(overlay_pci_node);
3712OVERLAY_INFO_EXTERN(overlay_bad_add_dup_node);
3713OVERLAY_INFO_EXTERN(overlay_bad_add_dup_prop);
3714OVERLAY_INFO_EXTERN(overlay_bad_phandle);
3715OVERLAY_INFO_EXTERN(overlay_bad_symbol);
3716OVERLAY_INFO_EXTERN(overlay_bad_unresolved);
3717
3718/* entries found by name */
3719static struct overlay_info overlays[] = {
3720	OVERLAY_INFO(overlay_base, -9999, 0),
3721	OVERLAY_INFO(overlay, 0, 0),
3722	OVERLAY_INFO(overlay_0, 0, 0),
3723	OVERLAY_INFO(overlay_1, 0, 0),
3724	OVERLAY_INFO(overlay_2, 0, 0),
3725	OVERLAY_INFO(overlay_3, 0, 0),
3726	OVERLAY_INFO(overlay_4, 0, 0),
3727	OVERLAY_INFO(overlay_5, 0, 0),
3728	OVERLAY_INFO(overlay_6, 0, 0),
3729	OVERLAY_INFO(overlay_7, 0, 0),
3730	OVERLAY_INFO(overlay_8, 0, 0),
3731	OVERLAY_INFO(overlay_9, 0, 0),
3732	OVERLAY_INFO(overlay_10, 0, 0),
3733	OVERLAY_INFO(overlay_11, 0, 0),
3734	OVERLAY_INFO(overlay_12, 0, 0),
3735	OVERLAY_INFO(overlay_13, 0, 0),
3736	OVERLAY_INFO(overlay_15, 0, 0),
3737	OVERLAY_INFO(overlay_16, -EBUSY, 0),
3738	OVERLAY_INFO(overlay_17, -EEXIST, 0),
3739	OVERLAY_INFO(overlay_18, 0, 0),
3740	OVERLAY_INFO(overlay_19, 0, 0),
3741	OVERLAY_INFO(overlay_20, 0, 0),
3742	OVERLAY_INFO(overlay_gpio_01, 0, 0),
3743	OVERLAY_INFO(overlay_gpio_02a, 0, 0),
3744	OVERLAY_INFO(overlay_gpio_02b, 0, 0),
3745	OVERLAY_INFO(overlay_gpio_03, 0, 0),
3746	OVERLAY_INFO(overlay_gpio_04a, 0, 0),
3747	OVERLAY_INFO(overlay_gpio_04b, 0, 0),
3748	OVERLAY_INFO(overlay_pci_node, 0, 0),
3749	OVERLAY_INFO(overlay_bad_add_dup_node, -EINVAL, -ENODEV),
3750	OVERLAY_INFO(overlay_bad_add_dup_prop, -EINVAL, -ENODEV),
3751	OVERLAY_INFO(overlay_bad_phandle, -EINVAL, 0),
3752	OVERLAY_INFO(overlay_bad_symbol, -EINVAL, -ENODEV),
3753	OVERLAY_INFO(overlay_bad_unresolved, -EINVAL, 0),
3754	/* end marker */
3755	{ }
3756};
3757
3758static struct device_node *overlay_base_root;
3759
3760static void * __init dt_alloc_memory(u64 size, u64 align)
3761{
3762	return memblock_alloc_or_panic(size, align);
3763}
3764
3765/*
3766 * Create base device tree for the overlay unittest.
3767 *
3768 * This is called from very early boot code.
3769 *
3770 * Do as much as possible the same way as done in __unflatten_device_tree
3771 * and other early boot steps for the normal FDT so that the overlay base
3772 * unflattened tree will have the same characteristics as the real tree
3773 * (such as having memory allocated by the early allocator).  The goal
3774 * is to test "the real thing" as much as possible, and test "test setup
3775 * code" as little as possible.
3776 *
3777 * Have to stop before resolving phandles, because that uses kmalloc.
3778 */
3779void __init unittest_unflatten_overlay_base(void)
3780{
3781	struct overlay_info *info;
3782	u32 data_size;
3783	void *new_fdt;
3784	u32 size;
3785	int found = 0;
3786	const char *overlay_name = "overlay_base";
3787
3788	for (info = overlays; info && info->name; info++) {
3789		if (!strcmp(overlay_name, info->name)) {
3790			found = 1;
3791			break;
3792		}
3793	}
3794	if (!found) {
3795		pr_err("no overlay data for %s\n", overlay_name);
3796		return;
3797	}
3798
3799	info = &overlays[0];
3800
3801	if (info->expected_result != -9999) {
3802		pr_err("No dtb 'overlay_base' to attach\n");
3803		return;
3804	}
3805
3806	data_size = info->dtbo_end - info->dtbo_begin;
3807	if (!data_size) {
3808		pr_err("No dtb 'overlay_base' to attach\n");
3809		return;
3810	}
3811
3812	size = fdt_totalsize(info->dtbo_begin);
3813	if (size != data_size) {
3814		pr_err("dtb 'overlay_base' header totalsize != actual size");
3815		return;
3816	}
3817
3818	new_fdt = dt_alloc_memory(size, roundup_pow_of_two(FDT_V17_SIZE));
3819	if (!new_fdt) {
3820		pr_err("alloc for dtb 'overlay_base' failed");
3821		return;
3822	}
3823
3824	memcpy(new_fdt, info->dtbo_begin, size);
3825
3826	__unflatten_device_tree(new_fdt, NULL, &overlay_base_root,
3827				dt_alloc_memory, true);
3828}
3829
3830/*
3831 * The purpose of of_unittest_overlay_data_add is to add an
3832 * overlay in the normal fashion.  This is a test of the whole
3833 * picture, instead of testing individual elements.
3834 *
3835 * A secondary purpose is to be able to verify that the contents of
3836 * /proc/device-tree/ contains the updated structure and values from
3837 * the overlay.  That must be verified separately in user space.
3838 *
3839 * Return 0 on unexpected error.
3840 */
3841static int __init overlay_data_apply(const char *overlay_name, int *ovcs_id)
3842{
3843	struct overlay_info *info;
3844	int passed = 1;
3845	int found = 0;
3846	int ret, ret2;
3847	u32 size;
3848
3849	for (info = overlays; info && info->name; info++) {
3850		if (!strcmp(overlay_name, info->name)) {
3851			found = 1;
3852			break;
3853		}
3854	}
3855	if (!found) {
3856		pr_err("no overlay data for %s\n", overlay_name);
3857		return 0;
3858	}
3859
3860	size = info->dtbo_end - info->dtbo_begin;
3861	if (!size)
3862		pr_err("no overlay data for %s\n", overlay_name);
3863
3864	ret = of_overlay_fdt_apply(info->dtbo_begin, size, &info->ovcs_id,
3865				   NULL);
3866	if (ovcs_id)
3867		*ovcs_id = info->ovcs_id;
3868	if (ret < 0)
3869		goto out;
3870
3871	pr_debug("%s applied\n", overlay_name);
3872
3873out:
3874	if (ret != info->expected_result) {
3875		pr_err("of_overlay_fdt_apply() expected %d, ret=%d, %s\n",
3876		       info->expected_result, ret, overlay_name);
3877		passed = 0;
3878	}
3879
3880	if (ret < 0) {
3881		/* changeset may be partially applied */
3882		ret2 = of_overlay_remove(&info->ovcs_id);
3883		if (ret2 != info->expected_result_remove) {
3884			pr_err("of_overlay_remove() expected %d, ret=%d, %s\n",
3885			       info->expected_result_remove, ret2,
3886			       overlay_name);
3887			passed = 0;
3888		}
3889	}
3890
3891	return passed;
3892}
3893
3894/*
3895 * The purpose of of_unittest_overlay_high_level is to add an overlay
3896 * in the normal fashion.  This is a test of the whole picture,
3897 * instead of individual elements.
3898 *
3899 * The first part of the function is _not_ normal overlay usage; it is
3900 * finishing splicing the base overlay device tree into the live tree.
3901 */
3902static __init void of_unittest_overlay_high_level(void)
3903{
3904	struct device_node *last_sibling;
3905	struct device_node *np;
3906	struct device_node *of_symbols;
3907	struct device_node *overlay_base_symbols;
3908	struct device_node **pprev;
3909	struct property *prop;
3910	int ret;
3911
3912	if (!overlay_base_root) {
3913		unittest(0, "overlay_base_root not initialized\n");
3914		return;
3915	}
3916
3917	/*
3918	 * Could not fixup phandles in unittest_unflatten_overlay_base()
3919	 * because kmalloc() was not yet available.
3920	 */
3921	of_overlay_mutex_lock();
3922	of_resolve_phandles(overlay_base_root);
3923	of_overlay_mutex_unlock();
3924
3925
3926	/*
3927	 * do not allow overlay_base to duplicate any node already in
3928	 * tree, this greatly simplifies the code
3929	 */
3930
3931	/*
3932	 * remove overlay_base_root node "__local_fixups", after
3933	 * being used by of_resolve_phandles()
3934	 */
3935	pprev = &overlay_base_root->child;
3936	for (np = overlay_base_root->child; np; np = np->sibling) {
3937		if (of_node_name_eq(np, "__local_fixups__")) {
3938			*pprev = np->sibling;
3939			break;
3940		}
3941		pprev = &np->sibling;
3942	}
3943
3944	/* remove overlay_base_root node "__symbols__" if in live tree */
3945	of_symbols = of_get_child_by_name(of_root, "__symbols__");
3946	if (of_symbols) {
3947		/* will have to graft properties from node into live tree */
3948		pprev = &overlay_base_root->child;
3949		for (np = overlay_base_root->child; np; np = np->sibling) {
3950			if (of_node_name_eq(np, "__symbols__")) {
3951				overlay_base_symbols = np;
3952				*pprev = np->sibling;
3953				break;
3954			}
3955			pprev = &np->sibling;
3956		}
3957	}
3958
3959	for_each_child_of_node(overlay_base_root, np) {
3960		struct device_node *base_child;
3961		for_each_child_of_node(of_root, base_child) {
3962			if (!strcmp(np->full_name, base_child->full_name)) {
3963				unittest(0, "illegal node name in overlay_base %pOFn",
3964					 np);
3965				of_node_put(np);
3966				of_node_put(base_child);
3967				return;
3968			}
3969		}
3970	}
3971
3972	/*
3973	 * overlay 'overlay_base' is not allowed to have root
3974	 * properties, so only need to splice nodes into main device tree.
3975	 *
3976	 * root node of *overlay_base_root will not be freed, it is lost
3977	 * memory.
3978	 */
3979
3980	for (np = overlay_base_root->child; np; np = np->sibling)
3981		np->parent = of_root;
3982
3983	mutex_lock(&of_mutex);
3984
3985	for (last_sibling = np = of_root->child; np; np = np->sibling)
3986		last_sibling = np;
3987
3988	if (last_sibling)
3989		last_sibling->sibling = overlay_base_root->child;
3990	else
3991		of_root->child = overlay_base_root->child;
3992
3993	for_each_of_allnodes_from(overlay_base_root, np)
3994		__of_attach_node_sysfs(np);
3995
3996	if (of_symbols) {
3997		struct property *new_prop;
3998		for_each_property_of_node(overlay_base_symbols, prop) {
3999
4000			new_prop = __of_prop_dup(prop, GFP_KERNEL);
4001			if (!new_prop) {
4002				unittest(0, "__of_prop_dup() of '%s' from overlay_base node __symbols__",
4003					 prop->name);
4004				goto err_unlock;
4005			}
4006			if (__of_add_property(of_symbols, new_prop)) {
4007				__of_prop_free(new_prop);
4008				/* "name" auto-generated by unflatten */
4009				if (!strcmp(prop->name, "name"))
4010					continue;
4011				unittest(0, "duplicate property '%s' in overlay_base node __symbols__",
4012					 prop->name);
4013				goto err_unlock;
4014			}
4015			if (__of_add_property_sysfs(of_symbols, new_prop)) {
4016				unittest(0, "unable to add property '%s' in overlay_base node __symbols__ to sysfs",
4017					 prop->name);
4018				goto err_unlock;
4019			}
4020		}
4021	}
4022
4023	mutex_unlock(&of_mutex);
4024
4025
4026	/* now do the normal overlay usage test */
4027
4028	/* ---  overlay  --- */
4029
4030	EXPECT_BEGIN(KERN_ERR,
4031		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/substation@100/status");
4032	EXPECT_BEGIN(KERN_ERR,
4033		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/status");
4034	EXPECT_BEGIN(KERN_ERR,
4035		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@30/incline-up");
4036	EXPECT_BEGIN(KERN_ERR,
4037		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@40/incline-up");
4038	EXPECT_BEGIN(KERN_ERR,
4039		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/status");
4040	EXPECT_BEGIN(KERN_ERR,
4041		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/color");
4042	EXPECT_BEGIN(KERN_ERR,
4043		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/rate");
4044	EXPECT_BEGIN(KERN_ERR,
4045		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/hvac_2");
4046	EXPECT_BEGIN(KERN_ERR,
4047		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200");
4048	EXPECT_BEGIN(KERN_ERR,
4049		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_left");
4050	EXPECT_BEGIN(KERN_ERR,
4051		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_right");
4052
4053	ret = overlay_data_apply("overlay", NULL);
4054
4055	EXPECT_END(KERN_ERR,
4056		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_right");
4057	EXPECT_END(KERN_ERR,
4058		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_left");
4059	EXPECT_END(KERN_ERR,
4060		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200");
4061	EXPECT_END(KERN_ERR,
4062		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/hvac_2");
4063	EXPECT_END(KERN_ERR,
4064		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/rate");
4065	EXPECT_END(KERN_ERR,
4066		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/color");
4067	EXPECT_END(KERN_ERR,
4068		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/status");
4069	EXPECT_END(KERN_ERR,
4070		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@40/incline-up");
4071	EXPECT_END(KERN_ERR,
4072		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@30/incline-up");
4073	EXPECT_END(KERN_ERR,
4074		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/status");
4075	EXPECT_END(KERN_ERR,
4076		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/substation@100/status");
4077
4078	unittest(ret, "Adding overlay 'overlay' failed\n");
4079
4080	/* ---  overlay_bad_add_dup_node  --- */
4081
4082	EXPECT_BEGIN(KERN_ERR,
4083		     "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/controller");
4084	EXPECT_BEGIN(KERN_ERR,
4085		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/controller/name");
4086	EXPECT_BEGIN(KERN_ERR,
4087		     "OF: changeset: apply failed: REMOVE_PROPERTY /testcase-data-2/substation@100/motor-1/controller:name");
4088	EXPECT_BEGIN(KERN_ERR,
4089		     "OF: Error reverting changeset (-19)");
4090
4091	unittest(overlay_data_apply("overlay_bad_add_dup_node", NULL),
4092		 "Adding overlay 'overlay_bad_add_dup_node' failed\n");
4093
4094	EXPECT_END(KERN_ERR,
4095		   "OF: Error reverting changeset (-19)");
4096	EXPECT_END(KERN_ERR,
4097		   "OF: changeset: apply failed: REMOVE_PROPERTY /testcase-data-2/substation@100/motor-1/controller:name");
4098	EXPECT_END(KERN_ERR,
4099		   "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/controller/name");
4100	EXPECT_END(KERN_ERR,
4101		   "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/controller");
4102
4103	/* ---  overlay_bad_add_dup_prop  --- */
4104
4105	EXPECT_BEGIN(KERN_ERR,
4106		     "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/electric");
4107	EXPECT_BEGIN(KERN_ERR,
4108		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/rpm_avail");
4109	EXPECT_BEGIN(KERN_ERR,
4110		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/name");
4111	EXPECT_BEGIN(KERN_ERR,
4112		     "OF: changeset: apply failed: REMOVE_PROPERTY /testcase-data-2/substation@100/motor-1/electric:name");
4113	EXPECT_BEGIN(KERN_ERR,
4114		     "OF: Error reverting changeset (-19)");
4115
4116	unittest(overlay_data_apply("overlay_bad_add_dup_prop", NULL),
4117		 "Adding overlay 'overlay_bad_add_dup_prop' failed\n");
4118
4119	EXPECT_END(KERN_ERR,
4120		   "OF: Error reverting changeset (-19)");
4121	EXPECT_END(KERN_ERR,
4122		   "OF: changeset: apply failed: REMOVE_PROPERTY /testcase-data-2/substation@100/motor-1/electric:name");
4123	EXPECT_END(KERN_ERR,
4124		   "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/name");
4125	EXPECT_END(KERN_ERR,
4126		   "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/rpm_avail");
4127	EXPECT_END(KERN_ERR,
4128		   "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/electric");
4129
4130	/* ---  overlay_bad_phandle  --- */
4131
4132	unittest(overlay_data_apply("overlay_bad_phandle", NULL),
4133		 "Adding overlay 'overlay_bad_phandle' failed\n");
4134
4135	/* ---  overlay_bad_symbol  --- */
4136
4137	EXPECT_BEGIN(KERN_ERR,
4138		     "OF: changeset: apply failed: REMOVE_PROPERTY /testcase-data-2/substation@100/hvac-medium-2:name");
4139	EXPECT_BEGIN(KERN_ERR,
4140		     "OF: Error reverting changeset (-19)");
4141
4142	unittest(overlay_data_apply("overlay_bad_symbol", NULL),
4143		 "Adding overlay 'overlay_bad_symbol' failed\n");
4144
4145	EXPECT_END(KERN_ERR,
4146		   "OF: Error reverting changeset (-19)");
4147	EXPECT_END(KERN_ERR,
4148		   "OF: changeset: apply failed: REMOVE_PROPERTY /testcase-data-2/substation@100/hvac-medium-2:name");
4149
4150	/* ---  overlay_bad_unresolved  --- */
4151
4152	EXPECT_BEGIN(KERN_ERR,
4153		     "OF: resolver: node label 'this_label_does_not_exist' not found in live devicetree symbols table");
4154	EXPECT_BEGIN(KERN_ERR,
4155		     "OF: resolver: overlay phandle fixup failed: -22");
4156
4157	unittest(overlay_data_apply("overlay_bad_unresolved", NULL),
4158		 "Adding overlay 'overlay_bad_unresolved' failed\n");
4159
4160	EXPECT_END(KERN_ERR,
4161		   "OF: resolver: overlay phandle fixup failed: -22");
4162	EXPECT_END(KERN_ERR,
4163		   "OF: resolver: node label 'this_label_does_not_exist' not found in live devicetree symbols table");
4164
4165	return;
4166
4167err_unlock:
4168	mutex_unlock(&of_mutex);
4169}
4170
4171static int of_unittest_pci_dev_num;
4172static int of_unittest_pci_child_num;
4173
4174/*
4175 * PCI device tree node test driver
4176 */
4177static const struct pci_device_id testdrv_pci_ids[] = {
4178	{ PCI_DEVICE(PCI_VENDOR_ID_REDHAT, 0x5), }, /* PCI_VENDOR_ID_REDHAT */
4179	{ 0, }
4180};
4181
4182static int testdrv_probe(struct pci_dev *pdev, const struct pci_device_id *id)
4183{
4184	struct overlay_info *info;
4185	struct device_node *dn;
4186	int ret, ovcs_id;
4187	u32 size;
4188
4189	dn = pdev->dev.of_node;
4190	if (!dn) {
4191		dev_err(&pdev->dev, "does not find bus endpoint");
4192		return -EINVAL;
4193	}
4194
4195	for (info = overlays; info && info->name; info++) {
4196		if (!strcmp(info->name, "overlay_pci_node"))
4197			break;
4198	}
4199	if (!info || !info->name) {
4200		dev_err(&pdev->dev, "no overlay data for overlay_pci_node");
4201		return -ENODEV;
4202	}
4203
4204	size = info->dtbo_end - info->dtbo_begin;
4205	ret = of_overlay_fdt_apply(info->dtbo_begin, size, &ovcs_id, dn);
4206	of_node_put(dn);
4207	if (ret)
4208		return ret;
4209
4210	of_platform_default_populate(dn, NULL, &pdev->dev);
4211	pci_set_drvdata(pdev, (void *)(uintptr_t)ovcs_id);
4212
4213	return 0;
4214}
4215
4216static void testdrv_remove(struct pci_dev *pdev)
4217{
4218	int ovcs_id = (int)(uintptr_t)pci_get_drvdata(pdev);
4219
4220	of_platform_depopulate(&pdev->dev);
4221	of_overlay_remove(&ovcs_id);
4222}
4223
4224static struct pci_driver testdrv_driver = {
4225	.name = "pci_dt_testdrv",
4226	.id_table = testdrv_pci_ids,
4227	.probe = testdrv_probe,
4228	.remove = testdrv_remove,
4229};
4230
4231static int unittest_pci_probe(struct platform_device *pdev)
4232{
4233	struct resource *res;
4234	struct device *dev;
4235	u64 exp_addr;
4236
4237	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
4238	if (!res)
4239		return -ENODEV;
4240
4241	dev = &pdev->dev;
4242	while (dev && !dev_is_pci(dev))
4243		dev = dev->parent;
4244	if (!dev) {
4245		pr_err("unable to find parent device\n");
4246		return -ENODEV;
4247	}
4248
4249	exp_addr = pci_resource_start(to_pci_dev(dev), 0) + 0x100;
4250	unittest(res->start == exp_addr, "Incorrect translated address %llx, expected %llx\n",
4251		 (u64)res->start, exp_addr);
4252
4253	of_unittest_pci_child_num++;
4254
4255	return 0;
4256}
4257
4258static const struct of_device_id unittest_pci_of_match[] = {
4259	{ .compatible = "unittest-pci" },
4260	{ }
4261};
4262
4263static struct platform_driver unittest_pci_driver = {
4264	.probe = unittest_pci_probe,
4265	.driver = {
4266		.name = "unittest-pci",
4267		.of_match_table = unittest_pci_of_match,
4268	},
4269};
4270
4271static int of_unittest_pci_node_verify(struct pci_dev *pdev, bool add)
4272{
4273	struct device_node *pnp, *np = NULL;
4274	struct device *child_dev;
4275	char *path = NULL;
4276	const __be32 *reg;
4277	int rc = 0;
4278
4279	pnp = pdev->dev.of_node;
4280	unittest(pnp, "Failed creating PCI dt node\n");
4281	if (!pnp)
4282		return -ENODEV;
4283
4284	if (add) {
4285		path = kasprintf(GFP_KERNEL, "%pOF/pci-ep-bus@0/unittest-pci@100", pnp);
4286		np = of_find_node_by_path(path);
4287		unittest(np, "Failed to get unittest-pci node under PCI node\n");
4288		if (!np) {
4289			rc = -ENODEV;
4290			goto failed;
4291		}
4292
4293		reg = of_get_property(np, "reg", NULL);
4294		unittest(reg, "Failed to get reg property\n");
4295		if (!reg)
4296			rc = -ENODEV;
4297	} else {
4298		path = kasprintf(GFP_KERNEL, "%pOF/pci-ep-bus@0", pnp);
4299		np = of_find_node_by_path(path);
4300		unittest(!np, "Child device tree node is not removed\n");
4301		child_dev = device_find_any_child(&pdev->dev);
4302		unittest(!child_dev, "Child device is not removed\n");
4303		put_device(child_dev);
4304	}
4305
4306failed:
4307	kfree(path);
4308	if (np)
4309		of_node_put(np);
4310
4311	return rc;
4312}
4313
4314static void __init of_unittest_pci_node(void)
4315{
4316	struct pci_dev *pdev = NULL;
4317	int rc;
4318
4319	if (!IS_ENABLED(CONFIG_PCI_DYNAMIC_OF_NODES))
4320		return;
4321
4322	rc = pci_register_driver(&testdrv_driver);
4323	unittest(!rc, "Failed to register pci test driver; rc = %d\n", rc);
4324	if (rc)
4325		return;
4326
4327	rc = platform_driver_register(&unittest_pci_driver);
4328	if (unittest(!rc, "Failed to register unittest pci driver\n")) {
4329		pci_unregister_driver(&testdrv_driver);
4330		return;
4331	}
4332
4333	while ((pdev = pci_get_device(PCI_VENDOR_ID_REDHAT, 0x5, pdev)) != NULL) {
4334		of_unittest_pci_node_verify(pdev, true);
4335		of_unittest_pci_dev_num++;
4336	}
4337	if (pdev)
4338		pci_dev_put(pdev);
4339
4340	unittest(of_unittest_pci_dev_num,
4341		 "No test PCI device been found. Please run QEMU with '-device pci-testdev'\n");
4342	unittest(of_unittest_pci_dev_num == of_unittest_pci_child_num,
4343		 "Child device number %d is not expected %d", of_unittest_pci_child_num,
4344		 of_unittest_pci_dev_num);
4345
4346	platform_driver_unregister(&unittest_pci_driver);
4347	pci_unregister_driver(&testdrv_driver);
4348
4349	while ((pdev = pci_get_device(PCI_VENDOR_ID_REDHAT, 0x5, pdev)) != NULL)
4350		of_unittest_pci_node_verify(pdev, false);
4351	if (pdev)
4352		pci_dev_put(pdev);
4353}
4354#else
4355
4356static inline __init void of_unittest_overlay_high_level(void) {}
4357static inline __init void of_unittest_pci_node(void) { }
4358
4359#endif
4360
4361static int __init of_unittest(void)
4362{
4363	struct device_node *np;
4364	int res;
4365
4366	pr_info("start of unittest - you will see error messages\n");
4367
4368	/* Taint the kernel so we know we've run tests. */
4369	add_taint(TAINT_TEST, LOCKDEP_STILL_OK);
4370
4371	/* adding data for unittest */
4372	res = unittest_data_add();
4373	if (res)
4374		return res;
4375	if (!of_aliases)
4376		of_aliases = of_find_node_by_path("/aliases");
4377
4378	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
4379	if (!np) {
4380		pr_info("No testcase data in device tree; not running tests\n");
4381		return 0;
4382	}
4383	of_node_put(np);
4384
4385	of_unittest_check_tree_linkage();
4386	of_unittest_check_phandles();
4387	of_unittest_find_node_by_name();
4388	of_unittest_dynamic();
4389	of_unittest_parse_phandle_with_args();
4390	of_unittest_parse_phandle_with_args_map();
4391	of_unittest_printf();
4392	of_unittest_property_string();
4393	of_unittest_property_copy();
4394	of_unittest_changeset();
4395	of_unittest_changeset_prop();
4396	of_unittest_parse_interrupts();
4397	of_unittest_parse_interrupts_extended();
4398	of_unittest_irq_refcount();
4399	of_unittest_dma_get_max_cpu_address();
4400	of_unittest_parse_dma_ranges();
4401	of_unittest_pci_dma_ranges();
4402	of_unittest_pci_empty_dma_ranges();
4403	of_unittest_bus_ranges();
4404	of_unittest_bus_3cell_ranges();
4405	of_unittest_reg();
4406	of_unittest_translate_addr();
4407	of_unittest_match_node();
4408	of_unittest_platform_populate();
4409	of_unittest_overlay();
4410	of_unittest_lifecycle();
4411	of_unittest_pci_node();
4412
4413	/* Double check linkage after removing testcase data */
4414	of_unittest_check_tree_linkage();
4415
4416	of_unittest_overlay_high_level();
4417
4418	pr_info("end of unittest - %i passed, %i failed\n",
4419		unittest_results.passed, unittest_results.failed);
4420
4421	return 0;
4422}
4423late_initcall(of_unittest);