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/kernel.h>
  26
  27#include <linux/i2c.h>
  28#include <linux/i2c-mux.h>
  29#include <linux/gpio/driver.h>
  30
  31#include <linux/bitops.h>
  32
  33#include "of_private.h"
  34
  35static struct unittest_results {
  36	int passed;
  37	int failed;
  38} unittest_results;
  39
  40#define unittest(result, fmt, ...) ({ \
  41	bool failed = !(result); \
  42	if (failed) { \
  43		unittest_results.failed++; \
  44		pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
  45	} else { \
  46		unittest_results.passed++; \
  47		pr_debug("pass %s():%i\n", __func__, __LINE__); \
  48	} \
  49	failed; \
  50})
  51
  52/*
  53 * Expected message may have a message level other than KERN_INFO.
  54 * Print the expected message only if the current loglevel will allow
  55 * the actual message to print.
  56 *
  57 * Do not use EXPECT_BEGIN() or EXPECT_END() for messages generated by
  58 * pr_debug().
  59 */
  60#define EXPECT_BEGIN(level, fmt, ...) \
  61	printk(level pr_fmt("EXPECT \\ : ") fmt, ##__VA_ARGS__)
  62
  63#define EXPECT_END(level, fmt, ...) \
  64	printk(level pr_fmt("EXPECT / : ") fmt, ##__VA_ARGS__)
  65
  66static void __init of_unittest_find_node_by_name(void)
  67{
  68	struct device_node *np;
  69	const char *options, *name;
  70
  71	np = of_find_node_by_path("/testcase-data");
  72	name = kasprintf(GFP_KERNEL, "%pOF", np);
  73	unittest(np && !strcmp("/testcase-data", name),
  74		"find /testcase-data failed\n");
  75	of_node_put(np);
  76	kfree(name);
  77
  78	/* Test if trailing '/' works */
  79	np = of_find_node_by_path("/testcase-data/");
  80	unittest(!np, "trailing '/' on /testcase-data/ should fail\n");
  81
  82	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
  83	name = kasprintf(GFP_KERNEL, "%pOF", np);
  84	unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
  85		"find /testcase-data/phandle-tests/consumer-a failed\n");
  86	of_node_put(np);
  87	kfree(name);
  88
  89	np = of_find_node_by_path("testcase-alias");
  90	name = kasprintf(GFP_KERNEL, "%pOF", np);
  91	unittest(np && !strcmp("/testcase-data", name),
  92		"find testcase-alias failed\n");
  93	of_node_put(np);
  94	kfree(name);
  95
  96	/* Test if trailing '/' works on aliases */
  97	np = of_find_node_by_path("testcase-alias/");
  98	unittest(!np, "trailing '/' on testcase-alias/ should fail\n");
  99
 100	np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
 101	name = kasprintf(GFP_KERNEL, "%pOF", np);
 102	unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
 103		"find testcase-alias/phandle-tests/consumer-a failed\n");
 104	of_node_put(np);
 105	kfree(name);
 106
 107	np = of_find_node_by_path("/testcase-data/missing-path");
 108	unittest(!np, "non-existent path returned node %pOF\n", np);
 109	of_node_put(np);
 110
 111	np = of_find_node_by_path("missing-alias");
 112	unittest(!np, "non-existent alias returned node %pOF\n", np);
 113	of_node_put(np);
 114
 115	np = of_find_node_by_path("testcase-alias/missing-path");
 116	unittest(!np, "non-existent alias with relative path returned node %pOF\n", np);
 117	of_node_put(np);
 118
 119	np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
 120	unittest(np && !strcmp("testoption", options),
 121		 "option path test failed\n");
 122	of_node_put(np);
 123
 124	np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
 125	unittest(np && !strcmp("test/option", options),
 126		 "option path test, subcase #1 failed\n");
 127	of_node_put(np);
 128
 129	np = of_find_node_opts_by_path("/testcase-data/testcase-device1:test/option", &options);
 130	unittest(np && !strcmp("test/option", options),
 131		 "option path test, subcase #2 failed\n");
 132	of_node_put(np);
 133
 134	np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
 135	unittest(np, "NULL option path test failed\n");
 136	of_node_put(np);
 137
 138	np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
 139				       &options);
 140	unittest(np && !strcmp("testaliasoption", options),
 141		 "option alias path test failed\n");
 142	of_node_put(np);
 143
 144	np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
 145				       &options);
 146	unittest(np && !strcmp("test/alias/option", options),
 147		 "option alias path test, subcase #1 failed\n");
 148	of_node_put(np);
 149
 150	np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
 151	unittest(np, "NULL option alias path test failed\n");
 152	of_node_put(np);
 153
 154	options = "testoption";
 155	np = of_find_node_opts_by_path("testcase-alias", &options);
 156	unittest(np && !options, "option clearing test failed\n");
 157	of_node_put(np);
 158
 159	options = "testoption";
 160	np = of_find_node_opts_by_path("/", &options);
 161	unittest(np && !options, "option clearing root node test failed\n");
 162	of_node_put(np);
 163}
 164
 165static void __init of_unittest_dynamic(void)
 166{
 167	struct device_node *np;
 168	struct property *prop;
 169
 170	np = of_find_node_by_path("/testcase-data");
 171	if (!np) {
 172		pr_err("missing testcase data\n");
 173		return;
 174	}
 175
 176	/* Array of 4 properties for the purpose of testing */
 177	prop = kcalloc(4, sizeof(*prop), GFP_KERNEL);
 178	if (!prop) {
 179		unittest(0, "kzalloc() failed\n");
 180		return;
 181	}
 182
 183	/* Add a new property - should pass*/
 184	prop->name = "new-property";
 185	prop->value = "new-property-data";
 186	prop->length = strlen(prop->value) + 1;
 187	unittest(of_add_property(np, prop) == 0, "Adding a new property failed\n");
 188
 189	/* Try to add an existing property - should fail */
 190	prop++;
 191	prop->name = "new-property";
 192	prop->value = "new-property-data-should-fail";
 193	prop->length = strlen(prop->value) + 1;
 194	unittest(of_add_property(np, prop) != 0,
 195		 "Adding an existing property should have failed\n");
 196
 197	/* Try to modify an existing property - should pass */
 198	prop->value = "modify-property-data-should-pass";
 199	prop->length = strlen(prop->value) + 1;
 200	unittest(of_update_property(np, prop) == 0,
 201		 "Updating an existing property should have passed\n");
 202
 203	/* Try to modify non-existent property - should pass*/
 204	prop++;
 205	prop->name = "modify-property";
 206	prop->value = "modify-missing-property-data-should-pass";
 207	prop->length = strlen(prop->value) + 1;
 208	unittest(of_update_property(np, prop) == 0,
 209		 "Updating a missing property should have passed\n");
 210
 211	/* Remove property - should pass */
 212	unittest(of_remove_property(np, prop) == 0,
 213		 "Removing a property should have passed\n");
 214
 215	/* Adding very large property - should pass */
 216	prop++;
 217	prop->name = "large-property-PAGE_SIZEx8";
 218	prop->length = PAGE_SIZE * 8;
 219	prop->value = kzalloc(prop->length, GFP_KERNEL);
 220	unittest(prop->value != NULL, "Unable to allocate large buffer\n");
 221	if (prop->value)
 222		unittest(of_add_property(np, prop) == 0,
 223			 "Adding a large property should have passed\n");
 224}
 225
 226static int __init of_unittest_check_node_linkage(struct device_node *np)
 227{
 228	struct device_node *child;
 229	int count = 0, rc;
 230
 231	for_each_child_of_node(np, child) {
 232		if (child->parent != np) {
 233			pr_err("Child node %pOFn links to wrong parent %pOFn\n",
 234				 child, np);
 235			rc = -EINVAL;
 236			goto put_child;
 237		}
 238
 239		rc = of_unittest_check_node_linkage(child);
 240		if (rc < 0)
 241			goto put_child;
 242		count += rc;
 243	}
 244
 245	return count + 1;
 246put_child:
 247	of_node_put(child);
 248	return rc;
 249}
 250
 251static void __init of_unittest_check_tree_linkage(void)
 252{
 253	struct device_node *np;
 254	int allnode_count = 0, child_count;
 255
 256	if (!of_root)
 257		return;
 258
 259	for_each_of_allnodes(np)
 260		allnode_count++;
 261	child_count = of_unittest_check_node_linkage(of_root);
 262
 263	unittest(child_count > 0, "Device node data structure is corrupted\n");
 264	unittest(child_count == allnode_count,
 265		 "allnodes list size (%i) doesn't match sibling lists size (%i)\n",
 266		 allnode_count, child_count);
 267	pr_debug("allnodes list size (%i); sibling lists size (%i)\n", allnode_count, child_count);
 268}
 269
 270static void __init of_unittest_printf_one(struct device_node *np, const char *fmt,
 271					  const char *expected)
 272{
 273	unsigned char *buf;
 274	int buf_size;
 275	int size, i;
 276
 277	buf_size = strlen(expected) + 10;
 278	buf = kmalloc(buf_size, GFP_KERNEL);
 279	if (!buf)
 280		return;
 281
 282	/* Baseline; check conversion with a large size limit */
 283	memset(buf, 0xff, buf_size);
 284	size = snprintf(buf, buf_size - 2, fmt, np);
 285
 286	/* use strcmp() instead of strncmp() here to be absolutely sure strings match */
 287	unittest((strcmp(buf, expected) == 0) && (buf[size+1] == 0xff),
 288		"sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
 289		fmt, expected, buf);
 290
 291	/* Make sure length limits work */
 292	size++;
 293	for (i = 0; i < 2; i++, size--) {
 294		/* Clear the buffer, and make sure it works correctly still */
 295		memset(buf, 0xff, buf_size);
 296		snprintf(buf, size+1, fmt, np);
 297		unittest(strncmp(buf, expected, size) == 0 && (buf[size+1] == 0xff),
 298			"snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
 299			size, fmt, expected, buf);
 300	}
 301	kfree(buf);
 302}
 303
 304static void __init of_unittest_printf(void)
 305{
 306	struct device_node *np;
 307	const char *full_name = "/testcase-data/platform-tests/test-device@1/dev@100";
 308	char phandle_str[16] = "";
 309
 310	np = of_find_node_by_path(full_name);
 311	if (!np) {
 312		unittest(np, "testcase data missing\n");
 313		return;
 314	}
 315
 316	num_to_str(phandle_str, sizeof(phandle_str), np->phandle, 0);
 317
 318	of_unittest_printf_one(np, "%pOF",  full_name);
 319	of_unittest_printf_one(np, "%pOFf", full_name);
 320	of_unittest_printf_one(np, "%pOFn", "dev");
 321	of_unittest_printf_one(np, "%2pOFn", "dev");
 322	of_unittest_printf_one(np, "%5pOFn", "  dev");
 323	of_unittest_printf_one(np, "%pOFnc", "dev:test-sub-device");
 324	of_unittest_printf_one(np, "%pOFp", phandle_str);
 325	of_unittest_printf_one(np, "%pOFP", "dev@100");
 326	of_unittest_printf_one(np, "ABC %pOFP ABC", "ABC dev@100 ABC");
 327	of_unittest_printf_one(np, "%10pOFP", "   dev@100");
 328	of_unittest_printf_one(np, "%-10pOFP", "dev@100   ");
 329	of_unittest_printf_one(of_root, "%pOFP", "/");
 330	of_unittest_printf_one(np, "%pOFF", "----");
 331	of_unittest_printf_one(np, "%pOFPF", "dev@100:----");
 332	of_unittest_printf_one(np, "%pOFPFPc", "dev@100:----:dev@100:test-sub-device");
 333	of_unittest_printf_one(np, "%pOFc", "test-sub-device");
 334	of_unittest_printf_one(np, "%pOFC",
 335			"\"test-sub-device\",\"test-compat2\",\"test-compat3\"");
 336}
 337
 338struct node_hash {
 339	struct hlist_node node;
 340	struct device_node *np;
 341};
 342
 343static DEFINE_HASHTABLE(phandle_ht, 8);
 344static void __init of_unittest_check_phandles(void)
 345{
 346	struct device_node *np;
 347	struct node_hash *nh;
 348	struct hlist_node *tmp;
 349	int i, dup_count = 0, phandle_count = 0;
 350
 351	for_each_of_allnodes(np) {
 352		if (!np->phandle)
 353			continue;
 354
 355		hash_for_each_possible(phandle_ht, nh, node, np->phandle) {
 356			if (nh->np->phandle == np->phandle) {
 357				pr_info("Duplicate phandle! %i used by %pOF and %pOF\n",
 358					np->phandle, nh->np, np);
 359				dup_count++;
 360				break;
 361			}
 362		}
 363
 364		nh = kzalloc(sizeof(*nh), GFP_KERNEL);
 365		if (!nh)
 366			return;
 367
 368		nh->np = np;
 369		hash_add(phandle_ht, &nh->node, np->phandle);
 370		phandle_count++;
 371	}
 372	unittest(dup_count == 0, "Found %i duplicates in %i phandles\n",
 373		 dup_count, phandle_count);
 374
 375	/* Clean up */
 376	hash_for_each_safe(phandle_ht, i, tmp, nh, node) {
 377		hash_del(&nh->node);
 378		kfree(nh);
 379	}
 380}
 381
 382static void __init of_unittest_parse_phandle_with_args(void)
 383{
 384	struct device_node *np;
 385	struct of_phandle_args args;
 386	int i, rc;
 387
 388	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
 389	if (!np) {
 390		pr_err("missing testcase data\n");
 391		return;
 392	}
 393
 394	rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
 395	unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
 396
 397	for (i = 0; i < 8; i++) {
 398		bool passed = true;
 399
 400		memset(&args, 0, sizeof(args));
 401		rc = of_parse_phandle_with_args(np, "phandle-list",
 402						"#phandle-cells", i, &args);
 403
 404		/* Test the values from tests-phandle.dtsi */
 405		switch (i) {
 406		case 0:
 407			passed &= !rc;
 408			passed &= (args.args_count == 1);
 409			passed &= (args.args[0] == (i + 1));
 410			break;
 411		case 1:
 412			passed &= !rc;
 413			passed &= (args.args_count == 2);
 414			passed &= (args.args[0] == (i + 1));
 415			passed &= (args.args[1] == 0);
 416			break;
 417		case 2:
 418			passed &= (rc == -ENOENT);
 419			break;
 420		case 3:
 421			passed &= !rc;
 422			passed &= (args.args_count == 3);
 423			passed &= (args.args[0] == (i + 1));
 424			passed &= (args.args[1] == 4);
 425			passed &= (args.args[2] == 3);
 426			break;
 427		case 4:
 428			passed &= !rc;
 429			passed &= (args.args_count == 2);
 430			passed &= (args.args[0] == (i + 1));
 431			passed &= (args.args[1] == 100);
 432			break;
 433		case 5:
 434			passed &= !rc;
 435			passed &= (args.args_count == 0);
 436			break;
 437		case 6:
 438			passed &= !rc;
 439			passed &= (args.args_count == 1);
 440			passed &= (args.args[0] == (i + 1));
 441			break;
 442		case 7:
 443			passed &= (rc == -ENOENT);
 444			break;
 445		default:
 446			passed = false;
 447		}
 448
 449		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
 450			 i, args.np, rc);
 451	}
 452
 453	/* Check for missing list property */
 454	memset(&args, 0, sizeof(args));
 455	rc = of_parse_phandle_with_args(np, "phandle-list-missing",
 456					"#phandle-cells", 0, &args);
 457	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 458	rc = of_count_phandle_with_args(np, "phandle-list-missing",
 459					"#phandle-cells");
 460	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 461
 462	/* Check for missing cells property */
 463	memset(&args, 0, sizeof(args));
 464
 465	EXPECT_BEGIN(KERN_INFO,
 466		     "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 467
 468	rc = of_parse_phandle_with_args(np, "phandle-list",
 469					"#phandle-cells-missing", 0, &args);
 470
 471	EXPECT_END(KERN_INFO,
 472		   "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 473
 474	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 475
 476	EXPECT_BEGIN(KERN_INFO,
 477		     "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 478
 479	rc = of_count_phandle_with_args(np, "phandle-list",
 480					"#phandle-cells-missing");
 481
 482	EXPECT_END(KERN_INFO,
 483		   "OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
 484
 485	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 486
 487	/* Check for bad phandle in list */
 488	memset(&args, 0, sizeof(args));
 489
 490	EXPECT_BEGIN(KERN_INFO,
 491		     "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 492
 493	rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle",
 494					"#phandle-cells", 0, &args);
 495
 496	EXPECT_END(KERN_INFO,
 497		   "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 498
 499	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 500
 501	EXPECT_BEGIN(KERN_INFO,
 502		     "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 503
 504	rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle",
 505					"#phandle-cells");
 506
 507	EXPECT_END(KERN_INFO,
 508		   "OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
 509
 510	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 511
 512	/* Check for incorrectly formed argument list */
 513	memset(&args, 0, sizeof(args));
 514
 515	EXPECT_BEGIN(KERN_INFO,
 516		     "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
 517
 518	rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
 519					"#phandle-cells", 1, &args);
 520
 521	EXPECT_END(KERN_INFO,
 522		   "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
 523
 524	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 525
 526	EXPECT_BEGIN(KERN_INFO,
 527		     "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
 528
 529	rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
 530					"#phandle-cells");
 531
 532	EXPECT_END(KERN_INFO,
 533		   "OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
 534
 535	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 536}
 537
 538static void __init of_unittest_parse_phandle_with_args_map(void)
 539{
 540	struct device_node *np, *p0, *p1, *p2, *p3;
 541	struct of_phandle_args args;
 542	int i, rc;
 543
 544	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-b");
 545	if (!np) {
 546		pr_err("missing testcase data\n");
 547		return;
 548	}
 549
 550	p0 = of_find_node_by_path("/testcase-data/phandle-tests/provider0");
 551	if (!p0) {
 552		pr_err("missing testcase data\n");
 553		return;
 554	}
 555
 556	p1 = of_find_node_by_path("/testcase-data/phandle-tests/provider1");
 557	if (!p1) {
 558		pr_err("missing testcase data\n");
 559		return;
 560	}
 561
 562	p2 = of_find_node_by_path("/testcase-data/phandle-tests/provider2");
 563	if (!p2) {
 564		pr_err("missing testcase data\n");
 565		return;
 566	}
 567
 568	p3 = of_find_node_by_path("/testcase-data/phandle-tests/provider3");
 569	if (!p3) {
 570		pr_err("missing testcase data\n");
 571		return;
 572	}
 573
 574	rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
 575	unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
 576
 577	for (i = 0; i < 8; i++) {
 578		bool passed = true;
 579
 580		memset(&args, 0, sizeof(args));
 581		rc = of_parse_phandle_with_args_map(np, "phandle-list",
 582						    "phandle", i, &args);
 583
 584		/* Test the values from tests-phandle.dtsi */
 585		switch (i) {
 586		case 0:
 587			passed &= !rc;
 588			passed &= (args.np == p1);
 589			passed &= (args.args_count == 1);
 590			passed &= (args.args[0] == 1);
 591			break;
 592		case 1:
 593			passed &= !rc;
 594			passed &= (args.np == p3);
 595			passed &= (args.args_count == 3);
 596			passed &= (args.args[0] == 2);
 597			passed &= (args.args[1] == 5);
 598			passed &= (args.args[2] == 3);
 599			break;
 600		case 2:
 601			passed &= (rc == -ENOENT);
 602			break;
 603		case 3:
 604			passed &= !rc;
 605			passed &= (args.np == p0);
 606			passed &= (args.args_count == 0);
 607			break;
 608		case 4:
 609			passed &= !rc;
 610			passed &= (args.np == p1);
 611			passed &= (args.args_count == 1);
 612			passed &= (args.args[0] == 3);
 613			break;
 614		case 5:
 615			passed &= !rc;
 616			passed &= (args.np == p0);
 617			passed &= (args.args_count == 0);
 618			break;
 619		case 6:
 620			passed &= !rc;
 621			passed &= (args.np == p2);
 622			passed &= (args.args_count == 2);
 623			passed &= (args.args[0] == 15);
 624			passed &= (args.args[1] == 0x20);
 625			break;
 626		case 7:
 627			passed &= (rc == -ENOENT);
 628			break;
 629		default:
 630			passed = false;
 631		}
 632
 633		unittest(passed, "index %i - data error on node %s rc=%i\n",
 634			 i, args.np->full_name, rc);
 635	}
 636
 637	/* Check for missing list property */
 638	memset(&args, 0, sizeof(args));
 639	rc = of_parse_phandle_with_args_map(np, "phandle-list-missing",
 640					    "phandle", 0, &args);
 641	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 642
 643	/* Check for missing cells,map,mask property */
 644	memset(&args, 0, sizeof(args));
 645
 646	EXPECT_BEGIN(KERN_INFO,
 647		     "OF: /testcase-data/phandle-tests/consumer-b: could not get #phandle-missing-cells for /testcase-data/phandle-tests/provider1");
 648
 649	rc = of_parse_phandle_with_args_map(np, "phandle-list",
 650					    "phandle-missing", 0, &args);
 651	EXPECT_END(KERN_INFO,
 652		   "OF: /testcase-data/phandle-tests/consumer-b: could not get #phandle-missing-cells for /testcase-data/phandle-tests/provider1");
 653
 654	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 655
 656	/* Check for bad phandle in list */
 657	memset(&args, 0, sizeof(args));
 658
 659	EXPECT_BEGIN(KERN_INFO,
 660		     "OF: /testcase-data/phandle-tests/consumer-b: could not find phandle");
 661
 662	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-phandle",
 663					    "phandle", 0, &args);
 664	EXPECT_END(KERN_INFO,
 665		   "OF: /testcase-data/phandle-tests/consumer-b: could not find phandle");
 666
 667	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 668
 669	/* Check for incorrectly formed argument list */
 670	memset(&args, 0, sizeof(args));
 671
 672	EXPECT_BEGIN(KERN_INFO,
 673		     "OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found -1");
 674
 675	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-args",
 676					    "phandle", 1, &args);
 677	EXPECT_END(KERN_INFO,
 678		   "OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found -1");
 679
 680	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 681}
 682
 683static void __init of_unittest_property_string(void)
 684{
 685	const char *strings[4];
 686	struct device_node *np;
 687	int rc;
 688
 689	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
 690	if (!np) {
 691		pr_err("No testcase data in device tree\n");
 692		return;
 693	}
 694
 695	rc = of_property_match_string(np, "phandle-list-names", "first");
 696	unittest(rc == 0, "first expected:0 got:%i\n", rc);
 697	rc = of_property_match_string(np, "phandle-list-names", "second");
 698	unittest(rc == 1, "second expected:1 got:%i\n", rc);
 699	rc = of_property_match_string(np, "phandle-list-names", "third");
 700	unittest(rc == 2, "third expected:2 got:%i\n", rc);
 701	rc = of_property_match_string(np, "phandle-list-names", "fourth");
 702	unittest(rc == -ENODATA, "unmatched string; rc=%i\n", rc);
 703	rc = of_property_match_string(np, "missing-property", "blah");
 704	unittest(rc == -EINVAL, "missing property; rc=%i\n", rc);
 705	rc = of_property_match_string(np, "empty-property", "blah");
 706	unittest(rc == -ENODATA, "empty property; rc=%i\n", rc);
 707	rc = of_property_match_string(np, "unterminated-string", "blah");
 708	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 709
 710	/* of_property_count_strings() tests */
 711	rc = of_property_count_strings(np, "string-property");
 712	unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 713	rc = of_property_count_strings(np, "phandle-list-names");
 714	unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 715	rc = of_property_count_strings(np, "unterminated-string");
 716	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 717	rc = of_property_count_strings(np, "unterminated-string-list");
 718	unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
 719
 720	/* of_property_read_string_index() tests */
 721	rc = of_property_read_string_index(np, "string-property", 0, strings);
 722	unittest(rc == 0 && !strcmp(strings[0], "foobar"), "of_property_read_string_index() failure; rc=%i\n", rc);
 723	strings[0] = NULL;
 724	rc = of_property_read_string_index(np, "string-property", 1, strings);
 725	unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 726	rc = of_property_read_string_index(np, "phandle-list-names", 0, strings);
 727	unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
 728	rc = of_property_read_string_index(np, "phandle-list-names", 1, strings);
 729	unittest(rc == 0 && !strcmp(strings[0], "second"), "of_property_read_string_index() failure; rc=%i\n", rc);
 730	rc = of_property_read_string_index(np, "phandle-list-names", 2, strings);
 731	unittest(rc == 0 && !strcmp(strings[0], "third"), "of_property_read_string_index() failure; rc=%i\n", rc);
 732	strings[0] = NULL;
 733	rc = of_property_read_string_index(np, "phandle-list-names", 3, strings);
 734	unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 735	strings[0] = NULL;
 736	rc = of_property_read_string_index(np, "unterminated-string", 0, strings);
 737	unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 738	rc = of_property_read_string_index(np, "unterminated-string-list", 0, strings);
 739	unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
 740	strings[0] = NULL;
 741	rc = of_property_read_string_index(np, "unterminated-string-list", 2, strings); /* should fail */
 742	unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 743	strings[1] = NULL;
 744
 745	/* of_property_read_string_array() tests */
 746	rc = of_property_read_string_array(np, "string-property", strings, 4);
 747	unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 748	rc = of_property_read_string_array(np, "phandle-list-names", strings, 4);
 749	unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 750	rc = of_property_read_string_array(np, "unterminated-string", strings, 4);
 751	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 752	/* -- An incorrectly formed string should cause a failure */
 753	rc = of_property_read_string_array(np, "unterminated-string-list", strings, 4);
 754	unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
 755	/* -- parsing the correctly formed strings should still work: */
 756	strings[2] = NULL;
 757	rc = of_property_read_string_array(np, "unterminated-string-list", strings, 2);
 758	unittest(rc == 2 && strings[2] == NULL, "of_property_read_string_array() failure; rc=%i\n", rc);
 759	strings[1] = NULL;
 760	rc = of_property_read_string_array(np, "phandle-list-names", strings, 1);
 761	unittest(rc == 1 && strings[1] == NULL, "Overwrote end of string array; rc=%i, str='%s'\n", rc, strings[1]);
 762}
 763
 764#define propcmp(p1, p2) (((p1)->length == (p2)->length) && \
 765			(p1)->value && (p2)->value && \
 766			!memcmp((p1)->value, (p2)->value, (p1)->length) && \
 767			!strcmp((p1)->name, (p2)->name))
 768static void __init of_unittest_property_copy(void)
 769{
 770#ifdef CONFIG_OF_DYNAMIC
 771	struct property p1 = { .name = "p1", .length = 0, .value = "" };
 772	struct property p2 = { .name = "p2", .length = 5, .value = "abcd" };
 773	struct property *new;
 774
 775	new = __of_prop_dup(&p1, GFP_KERNEL);
 776	unittest(new && propcmp(&p1, new), "empty property didn't copy correctly\n");
 777	kfree(new->value);
 778	kfree(new->name);
 779	kfree(new);
 780
 781	new = __of_prop_dup(&p2, GFP_KERNEL);
 782	unittest(new && propcmp(&p2, new), "non-empty property didn't copy correctly\n");
 783	kfree(new->value);
 784	kfree(new->name);
 785	kfree(new);
 786#endif
 787}
 788
 789static void __init of_unittest_changeset(void)
 790{
 791#ifdef CONFIG_OF_DYNAMIC
 792	struct property *ppadd, padd = { .name = "prop-add", .length = 1, .value = "" };
 793	struct property *ppname_n1,  pname_n1  = { .name = "name", .length = 3, .value = "n1"  };
 794	struct property *ppname_n2,  pname_n2  = { .name = "name", .length = 3, .value = "n2"  };
 795	struct property *ppname_n21, pname_n21 = { .name = "name", .length = 3, .value = "n21" };
 796	struct property *ppupdate, pupdate = { .name = "prop-update", .length = 5, .value = "abcd" };
 797	struct property *ppremove;
 798	struct device_node *n1, *n2, *n21, *nchangeset, *nremove, *parent, *np;
 799	struct of_changeset chgset;
 800
 801	n1 = __of_node_dup(NULL, "n1");
 802	unittest(n1, "testcase setup failure\n");
 803
 804	n2 = __of_node_dup(NULL, "n2");
 805	unittest(n2, "testcase setup failure\n");
 806
 807	n21 = __of_node_dup(NULL, "n21");
 808	unittest(n21, "testcase setup failure %p\n", n21);
 809
 810	nchangeset = of_find_node_by_path("/testcase-data/changeset");
 811	nremove = of_get_child_by_name(nchangeset, "node-remove");
 812	unittest(nremove, "testcase setup failure\n");
 813
 814	ppadd = __of_prop_dup(&padd, GFP_KERNEL);
 815	unittest(ppadd, "testcase setup failure\n");
 816
 817	ppname_n1  = __of_prop_dup(&pname_n1, GFP_KERNEL);
 818	unittest(ppname_n1, "testcase setup failure\n");
 819
 820	ppname_n2  = __of_prop_dup(&pname_n2, GFP_KERNEL);
 821	unittest(ppname_n2, "testcase setup failure\n");
 822
 823	ppname_n21 = __of_prop_dup(&pname_n21, GFP_KERNEL);
 824	unittest(ppname_n21, "testcase setup failure\n");
 825
 826	ppupdate = __of_prop_dup(&pupdate, GFP_KERNEL);
 827	unittest(ppupdate, "testcase setup failure\n");
 828
 829	parent = nchangeset;
 830	n1->parent = parent;
 831	n2->parent = parent;
 832	n21->parent = n2;
 833
 834	ppremove = of_find_property(parent, "prop-remove", NULL);
 835	unittest(ppremove, "failed to find removal prop");
 836
 837	of_changeset_init(&chgset);
 838
 839	unittest(!of_changeset_attach_node(&chgset, n1), "fail attach n1\n");
 840	unittest(!of_changeset_add_property(&chgset, n1, ppname_n1), "fail add prop name\n");
 841
 842	unittest(!of_changeset_attach_node(&chgset, n2), "fail attach n2\n");
 843	unittest(!of_changeset_add_property(&chgset, n2, ppname_n2), "fail add prop name\n");
 844
 845	unittest(!of_changeset_detach_node(&chgset, nremove), "fail remove node\n");
 846	unittest(!of_changeset_add_property(&chgset, n21, ppname_n21), "fail add prop name\n");
 847
 848	unittest(!of_changeset_attach_node(&chgset, n21), "fail attach n21\n");
 849
 850	unittest(!of_changeset_add_property(&chgset, parent, ppadd), "fail add prop prop-add\n");
 851	unittest(!of_changeset_update_property(&chgset, parent, ppupdate), "fail update prop\n");
 852	unittest(!of_changeset_remove_property(&chgset, parent, ppremove), "fail remove prop\n");
 853
 854	unittest(!of_changeset_apply(&chgset), "apply failed\n");
 855
 856	of_node_put(nchangeset);
 857
 858	/* Make sure node names are constructed correctly */
 859	unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n21")),
 860		 "'%pOF' not added\n", n21);
 861	of_node_put(np);
 862
 863	unittest(!of_changeset_revert(&chgset), "revert failed\n");
 864
 865	of_changeset_destroy(&chgset);
 866
 867	of_node_put(n1);
 868	of_node_put(n2);
 869	of_node_put(n21);
 870#endif
 871}
 872
 873static void __init of_unittest_dma_get_max_cpu_address(void)
 874{
 875	struct device_node *np;
 876	phys_addr_t cpu_addr;
 877
 878	if (!IS_ENABLED(CONFIG_OF_ADDRESS))
 879		return;
 880
 881	np = of_find_node_by_path("/testcase-data/address-tests");
 882	if (!np) {
 883		pr_err("missing testcase data\n");
 884		return;
 885	}
 886
 887	cpu_addr = of_dma_get_max_cpu_address(np);
 888	unittest(cpu_addr == 0x4fffffff,
 889		 "of_dma_get_max_cpu_address: wrong CPU addr %pad (expecting %x)\n",
 890		 &cpu_addr, 0x4fffffff);
 891}
 892
 893static void __init of_unittest_dma_ranges_one(const char *path,
 894		u64 expect_dma_addr, u64 expect_paddr)
 895{
 896#ifdef CONFIG_HAS_DMA
 897	struct device_node *np;
 898	const struct bus_dma_region *map = NULL;
 899	int rc;
 900
 901	np = of_find_node_by_path(path);
 902	if (!np) {
 903		pr_err("missing testcase data\n");
 904		return;
 905	}
 906
 907	rc = of_dma_get_range(np, &map);
 908
 909	unittest(!rc, "of_dma_get_range failed on node %pOF rc=%i\n", np, rc);
 910
 911	if (!rc) {
 912		phys_addr_t	paddr;
 913		dma_addr_t	dma_addr;
 914		struct device	dev_bogus;
 915
 916		dev_bogus.dma_range_map = map;
 917		paddr = dma_to_phys(&dev_bogus, expect_dma_addr);
 918		dma_addr = phys_to_dma(&dev_bogus, expect_paddr);
 919
 920		unittest(paddr == expect_paddr,
 921			 "of_dma_get_range: wrong phys addr %pap (expecting %llx) on node %pOF\n",
 922			 &paddr, expect_paddr, np);
 923		unittest(dma_addr == expect_dma_addr,
 924			 "of_dma_get_range: wrong DMA addr %pad (expecting %llx) on node %pOF\n",
 925			 &dma_addr, expect_dma_addr, np);
 926
 927		kfree(map);
 928	}
 929	of_node_put(np);
 930#endif
 931}
 932
 933static void __init of_unittest_parse_dma_ranges(void)
 934{
 935	of_unittest_dma_ranges_one("/testcase-data/address-tests/device@70000000",
 936		0x0, 0x20000000);
 937	of_unittest_dma_ranges_one("/testcase-data/address-tests/bus@80000000/device@1000",
 938		0x100000000, 0x20000000);
 939	of_unittest_dma_ranges_one("/testcase-data/address-tests/pci@90000000",
 940		0x80000000, 0x20000000);
 941}
 942
 943static void __init of_unittest_pci_dma_ranges(void)
 944{
 945	struct device_node *np;
 946	struct of_pci_range range;
 947	struct of_pci_range_parser parser;
 948	int i = 0;
 949
 950	if (!IS_ENABLED(CONFIG_PCI))
 951		return;
 952
 953	np = of_find_node_by_path("/testcase-data/address-tests/pci@90000000");
 954	if (!np) {
 955		pr_err("missing testcase data\n");
 956		return;
 957	}
 958
 959	if (of_pci_dma_range_parser_init(&parser, np)) {
 960		pr_err("missing dma-ranges property\n");
 961		return;
 962	}
 963
 964	/*
 965	 * Get the dma-ranges from the device tree
 966	 */
 967	for_each_of_pci_range(&parser, &range) {
 968		if (!i) {
 969			unittest(range.size == 0x10000000,
 970				 "for_each_of_pci_range wrong size on node %pOF size=%llx\n",
 971				 np, range.size);
 972			unittest(range.cpu_addr == 0x20000000,
 973				 "for_each_of_pci_range wrong CPU addr (%llx) on node %pOF",
 974				 range.cpu_addr, np);
 975			unittest(range.pci_addr == 0x80000000,
 976				 "for_each_of_pci_range wrong DMA addr (%llx) on node %pOF",
 977				 range.pci_addr, np);
 978		} else {
 979			unittest(range.size == 0x10000000,
 980				 "for_each_of_pci_range wrong size on node %pOF size=%llx\n",
 981				 np, range.size);
 982			unittest(range.cpu_addr == 0x40000000,
 983				 "for_each_of_pci_range wrong CPU addr (%llx) on node %pOF",
 984				 range.cpu_addr, np);
 985			unittest(range.pci_addr == 0xc0000000,
 986				 "for_each_of_pci_range wrong DMA addr (%llx) on node %pOF",
 987				 range.pci_addr, np);
 988		}
 989		i++;
 990	}
 991
 992	of_node_put(np);
 993}
 994
 995static void __init of_unittest_parse_interrupts(void)
 996{
 997	struct device_node *np;
 998	struct of_phandle_args args;
 999	int i, rc;
1000
1001	if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
1002		return;
1003
1004	np = of_find_node_by_path("/testcase-data/interrupts/interrupts0");
1005	if (!np) {
1006		pr_err("missing testcase data\n");
1007		return;
1008	}
1009
1010	for (i = 0; i < 4; i++) {
1011		bool passed = true;
1012
1013		memset(&args, 0, sizeof(args));
1014		rc = of_irq_parse_one(np, i, &args);
1015
1016		passed &= !rc;
1017		passed &= (args.args_count == 1);
1018		passed &= (args.args[0] == (i + 1));
1019
1020		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
1021			 i, args.np, rc);
1022	}
1023	of_node_put(np);
1024
1025	np = of_find_node_by_path("/testcase-data/interrupts/interrupts1");
1026	if (!np) {
1027		pr_err("missing testcase data\n");
1028		return;
1029	}
1030
1031	for (i = 0; i < 4; i++) {
1032		bool passed = true;
1033
1034		memset(&args, 0, sizeof(args));
1035		rc = of_irq_parse_one(np, i, &args);
1036
1037		/* Test the values from tests-phandle.dtsi */
1038		switch (i) {
1039		case 0:
1040			passed &= !rc;
1041			passed &= (args.args_count == 1);
1042			passed &= (args.args[0] == 9);
1043			break;
1044		case 1:
1045			passed &= !rc;
1046			passed &= (args.args_count == 3);
1047			passed &= (args.args[0] == 10);
1048			passed &= (args.args[1] == 11);
1049			passed &= (args.args[2] == 12);
1050			break;
1051		case 2:
1052			passed &= !rc;
1053			passed &= (args.args_count == 2);
1054			passed &= (args.args[0] == 13);
1055			passed &= (args.args[1] == 14);
1056			break;
1057		case 3:
1058			passed &= !rc;
1059			passed &= (args.args_count == 2);
1060			passed &= (args.args[0] == 15);
1061			passed &= (args.args[1] == 16);
1062			break;
1063		default:
1064			passed = false;
1065		}
1066		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
1067			 i, args.np, rc);
1068	}
1069	of_node_put(np);
1070}
1071
1072static void __init of_unittest_parse_interrupts_extended(void)
1073{
1074	struct device_node *np;
1075	struct of_phandle_args args;
1076	int i, rc;
1077
1078	if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
1079		return;
1080
1081	np = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0");
1082	if (!np) {
1083		pr_err("missing testcase data\n");
1084		return;
1085	}
1086
1087	for (i = 0; i < 7; i++) {
1088		bool passed = true;
1089
1090		memset(&args, 0, sizeof(args));
1091		rc = of_irq_parse_one(np, i, &args);
1092
1093		/* Test the values from tests-phandle.dtsi */
1094		switch (i) {
1095		case 0:
1096			passed &= !rc;
1097			passed &= (args.args_count == 1);
1098			passed &= (args.args[0] == 1);
1099			break;
1100		case 1:
1101			passed &= !rc;
1102			passed &= (args.args_count == 3);
1103			passed &= (args.args[0] == 2);
1104			passed &= (args.args[1] == 3);
1105			passed &= (args.args[2] == 4);
1106			break;
1107		case 2:
1108			passed &= !rc;
1109			passed &= (args.args_count == 2);
1110			passed &= (args.args[0] == 5);
1111			passed &= (args.args[1] == 6);
1112			break;
1113		case 3:
1114			passed &= !rc;
1115			passed &= (args.args_count == 1);
1116			passed &= (args.args[0] == 9);
1117			break;
1118		case 4:
1119			passed &= !rc;
1120			passed &= (args.args_count == 3);
1121			passed &= (args.args[0] == 10);
1122			passed &= (args.args[1] == 11);
1123			passed &= (args.args[2] == 12);
1124			break;
1125		case 5:
1126			passed &= !rc;
1127			passed &= (args.args_count == 2);
1128			passed &= (args.args[0] == 13);
1129			passed &= (args.args[1] == 14);
1130			break;
1131		case 6:
1132			passed &= !rc;
1133			passed &= (args.args_count == 1);
1134			passed &= (args.args[0] == 15);
1135			break;
1136		default:
1137			passed = false;
1138		}
1139
1140		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
1141			 i, args.np, rc);
1142	}
1143	of_node_put(np);
1144}
1145
1146static const struct of_device_id match_node_table[] = {
1147	{ .data = "A", .name = "name0", }, /* Name alone is lowest priority */
1148	{ .data = "B", .type = "type1", }, /* followed by type alone */
1149
1150	{ .data = "Ca", .name = "name2", .type = "type1", }, /* followed by both together */
1151	{ .data = "Cb", .name = "name2", }, /* Only match when type doesn't match */
1152	{ .data = "Cc", .name = "name2", .type = "type2", },
1153
1154	{ .data = "E", .compatible = "compat3" },
1155	{ .data = "G", .compatible = "compat2", },
1156	{ .data = "H", .compatible = "compat2", .name = "name5", },
1157	{ .data = "I", .compatible = "compat2", .type = "type1", },
1158	{ .data = "J", .compatible = "compat2", .type = "type1", .name = "name8", },
1159	{ .data = "K", .compatible = "compat2", .name = "name9", },
1160	{}
1161};
1162
1163static struct {
1164	const char *path;
1165	const char *data;
1166} match_node_tests[] = {
1167	{ .path = "/testcase-data/match-node/name0", .data = "A", },
1168	{ .path = "/testcase-data/match-node/name1", .data = "B", },
1169	{ .path = "/testcase-data/match-node/a/name2", .data = "Ca", },
1170	{ .path = "/testcase-data/match-node/b/name2", .data = "Cb", },
1171	{ .path = "/testcase-data/match-node/c/name2", .data = "Cc", },
1172	{ .path = "/testcase-data/match-node/name3", .data = "E", },
1173	{ .path = "/testcase-data/match-node/name4", .data = "G", },
1174	{ .path = "/testcase-data/match-node/name5", .data = "H", },
1175	{ .path = "/testcase-data/match-node/name6", .data = "G", },
1176	{ .path = "/testcase-data/match-node/name7", .data = "I", },
1177	{ .path = "/testcase-data/match-node/name8", .data = "J", },
1178	{ .path = "/testcase-data/match-node/name9", .data = "K", },
1179};
1180
1181static void __init of_unittest_match_node(void)
1182{
1183	struct device_node *np;
1184	const struct of_device_id *match;
1185	int i;
1186
1187	for (i = 0; i < ARRAY_SIZE(match_node_tests); i++) {
1188		np = of_find_node_by_path(match_node_tests[i].path);
1189		if (!np) {
1190			unittest(0, "missing testcase node %s\n",
1191				match_node_tests[i].path);
1192			continue;
1193		}
1194
1195		match = of_match_node(match_node_table, np);
1196		if (!match) {
1197			unittest(0, "%s didn't match anything\n",
1198				match_node_tests[i].path);
1199			continue;
1200		}
1201
1202		if (strcmp(match->data, match_node_tests[i].data) != 0) {
1203			unittest(0, "%s got wrong match. expected %s, got %s\n",
1204				match_node_tests[i].path, match_node_tests[i].data,
1205				(const char *)match->data);
1206			continue;
1207		}
1208		unittest(1, "passed");
1209	}
1210}
1211
1212static struct resource test_bus_res = DEFINE_RES_MEM(0xfffffff8, 2);
1213static const struct platform_device_info test_bus_info = {
1214	.name = "unittest-bus",
1215};
1216static void __init of_unittest_platform_populate(void)
1217{
1218	int irq, rc;
1219	struct device_node *np, *child, *grandchild;
1220	struct platform_device *pdev, *test_bus;
1221	const struct of_device_id match[] = {
1222		{ .compatible = "test-device", },
1223		{}
1224	};
1225
1226	np = of_find_node_by_path("/testcase-data");
1227	of_platform_default_populate(np, NULL, NULL);
1228
1229	/* Test that a missing irq domain returns -EPROBE_DEFER */
1230	np = of_find_node_by_path("/testcase-data/testcase-device1");
1231	pdev = of_find_device_by_node(np);
1232	unittest(pdev, "device 1 creation failed\n");
1233
1234	if (!(of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)) {
1235		irq = platform_get_irq(pdev, 0);
1236		unittest(irq == -EPROBE_DEFER,
1237			 "device deferred probe failed - %d\n", irq);
1238
1239		/* Test that a parsing failure does not return -EPROBE_DEFER */
1240		np = of_find_node_by_path("/testcase-data/testcase-device2");
1241		pdev = of_find_device_by_node(np);
1242		unittest(pdev, "device 2 creation failed\n");
1243
1244		EXPECT_BEGIN(KERN_INFO,
1245			     "platform testcase-data:testcase-device2: IRQ index 0 not found");
1246
1247		irq = platform_get_irq(pdev, 0);
1248
1249		EXPECT_END(KERN_INFO,
1250			   "platform testcase-data:testcase-device2: IRQ index 0 not found");
1251
1252		unittest(irq < 0 && irq != -EPROBE_DEFER,
1253			 "device parsing error failed - %d\n", irq);
1254	}
1255
1256	np = of_find_node_by_path("/testcase-data/platform-tests");
1257	unittest(np, "No testcase data in device tree\n");
1258	if (!np)
1259		return;
1260
1261	test_bus = platform_device_register_full(&test_bus_info);
1262	rc = PTR_ERR_OR_ZERO(test_bus);
1263	unittest(!rc, "testbus registration failed; rc=%i\n", rc);
1264	if (rc) {
1265		of_node_put(np);
1266		return;
1267	}
1268	test_bus->dev.of_node = np;
1269
1270	/*
1271	 * Add a dummy resource to the test bus node after it is
1272	 * registered to catch problems with un-inserted resources. The
1273	 * DT code doesn't insert the resources, and it has caused the
1274	 * kernel to oops in the past. This makes sure the same bug
1275	 * doesn't crop up again.
1276	 */
1277	platform_device_add_resources(test_bus, &test_bus_res, 1);
1278
1279	of_platform_populate(np, match, NULL, &test_bus->dev);
1280	for_each_child_of_node(np, child) {
1281		for_each_child_of_node(child, grandchild) {
1282			pdev = of_find_device_by_node(grandchild);
1283			unittest(pdev,
1284				 "Could not create device for node '%pOFn'\n",
1285				 grandchild);
1286			platform_device_put(pdev);
1287		}
1288	}
1289
1290	of_platform_depopulate(&test_bus->dev);
1291	for_each_child_of_node(np, child) {
1292		for_each_child_of_node(child, grandchild)
1293			unittest(!of_find_device_by_node(grandchild),
1294				 "device didn't get destroyed '%pOFn'\n",
1295				 grandchild);
1296	}
1297
1298	platform_device_unregister(test_bus);
1299	of_node_put(np);
1300}
1301
1302/**
1303 *	update_node_properties - adds the properties
1304 *	of np into dup node (present in live tree) and
1305 *	updates parent of children of np to dup.
1306 *
1307 *	@np:	node whose properties are being added to the live tree
1308 *	@dup:	node present in live tree to be updated
1309 */
1310static void update_node_properties(struct device_node *np,
1311					struct device_node *dup)
1312{
1313	struct property *prop;
1314	struct property *save_next;
1315	struct device_node *child;
1316	int ret;
1317
1318	for_each_child_of_node(np, child)
1319		child->parent = dup;
1320
1321	/*
1322	 * "unittest internal error: unable to add testdata property"
1323	 *
1324	 *    If this message reports a property in node '/__symbols__' then
1325	 *    the respective unittest overlay contains a label that has the
1326	 *    same name as a label in the live devicetree.  The label will
1327	 *    be in the live devicetree only if the devicetree source was
1328	 *    compiled with the '-@' option.  If you encounter this error,
1329	 *    please consider renaming __all__ of the labels in the unittest
1330	 *    overlay dts files with an odd prefix that is unlikely to be
1331	 *    used in a real devicetree.
1332	 */
1333
1334	/*
1335	 * open code for_each_property_of_node() because of_add_property()
1336	 * sets prop->next to NULL
1337	 */
1338	for (prop = np->properties; prop != NULL; prop = save_next) {
1339		save_next = prop->next;
1340		ret = of_add_property(dup, prop);
1341		if (ret) {
1342			if (ret == -EEXIST && !strcmp(prop->name, "name"))
1343				continue;
1344			pr_err("unittest internal error: unable to add testdata property %pOF/%s",
1345			       np, prop->name);
1346		}
1347	}
1348}
1349
1350/**
1351 *	attach_node_and_children - attaches nodes
1352 *	and its children to live tree.
1353 *	CAUTION: misleading function name - if node @np already exists in
1354 *	the live tree then children of @np are *not* attached to the live
1355 *	tree.  This works for the current test devicetree nodes because such
1356 *	nodes do not have child nodes.
1357 *
1358 *	@np:	Node to attach to live tree
1359 */
1360static void attach_node_and_children(struct device_node *np)
1361{
1362	struct device_node *next, *dup, *child;
1363	unsigned long flags;
1364	const char *full_name;
1365
1366	full_name = kasprintf(GFP_KERNEL, "%pOF", np);
1367
1368	if (!strcmp(full_name, "/__local_fixups__") ||
1369	    !strcmp(full_name, "/__fixups__")) {
1370		kfree(full_name);
1371		return;
1372	}
1373
1374	dup = of_find_node_by_path(full_name);
1375	kfree(full_name);
1376	if (dup) {
1377		update_node_properties(np, dup);
1378		return;
1379	}
1380
1381	child = np->child;
1382	np->child = NULL;
1383
1384	mutex_lock(&of_mutex);
1385	raw_spin_lock_irqsave(&devtree_lock, flags);
1386	np->sibling = np->parent->child;
1387	np->parent->child = np;
1388	of_node_clear_flag(np, OF_DETACHED);
1389	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1390
1391	__of_attach_node_sysfs(np);
1392	mutex_unlock(&of_mutex);
1393
1394	while (child) {
1395		next = child->sibling;
1396		attach_node_and_children(child);
1397		child = next;
1398	}
1399}
1400
1401/**
1402 *	unittest_data_add - Reads, copies data from
1403 *	linked tree and attaches it to the live tree
1404 */
1405static int __init unittest_data_add(void)
1406{
1407	void *unittest_data;
1408	void *unittest_data_align;
1409	struct device_node *unittest_data_node = NULL, *np;
1410	/*
1411	 * __dtb_testcases_begin[] and __dtb_testcases_end[] are magically
1412	 * created by cmd_dt_S_dtb in scripts/Makefile.lib
1413	 */
1414	extern uint8_t __dtb_testcases_begin[];
1415	extern uint8_t __dtb_testcases_end[];
1416	const int size = __dtb_testcases_end - __dtb_testcases_begin;
1417	int rc;
1418	void *ret;
1419
1420	if (!size) {
1421		pr_warn("%s: testcases is empty\n", __func__);
1422		return -ENODATA;
1423	}
1424
1425	/* creating copy */
1426	unittest_data = kmalloc(size + FDT_ALIGN_SIZE, GFP_KERNEL);
1427	if (!unittest_data)
1428		return -ENOMEM;
1429
1430	unittest_data_align = PTR_ALIGN(unittest_data, FDT_ALIGN_SIZE);
1431	memcpy(unittest_data_align, __dtb_testcases_begin, size);
1432
1433	ret = of_fdt_unflatten_tree(unittest_data_align, NULL, &unittest_data_node);
1434	if (!ret) {
1435		pr_warn("%s: unflatten testcases tree failed\n", __func__);
1436		kfree(unittest_data);
1437		return -ENODATA;
1438	}
1439	if (!unittest_data_node) {
1440		pr_warn("%s: testcases tree is empty\n", __func__);
1441		kfree(unittest_data);
1442		return -ENODATA;
1443	}
1444
1445	/*
1446	 * This lock normally encloses of_resolve_phandles()
1447	 */
1448	of_overlay_mutex_lock();
1449
1450	rc = of_resolve_phandles(unittest_data_node);
1451	if (rc) {
1452		pr_err("%s: Failed to resolve phandles (rc=%i)\n", __func__, rc);
1453		of_overlay_mutex_unlock();
1454		return -EINVAL;
1455	}
1456
1457	if (!of_root) {
1458		of_root = unittest_data_node;
1459		for_each_of_allnodes(np)
1460			__of_attach_node_sysfs(np);
1461		of_aliases = of_find_node_by_path("/aliases");
1462		of_chosen = of_find_node_by_path("/chosen");
1463		of_overlay_mutex_unlock();
1464		return 0;
1465	}
1466
1467	EXPECT_BEGIN(KERN_INFO,
1468		     "Duplicate name in testcase-data, renamed to \"duplicate-name#1\"");
1469
1470	/* attach the sub-tree to live tree */
1471	np = unittest_data_node->child;
1472	while (np) {
1473		struct device_node *next = np->sibling;
1474
1475		np->parent = of_root;
1476		attach_node_and_children(np);
1477		np = next;
1478	}
1479
1480	EXPECT_END(KERN_INFO,
1481		   "Duplicate name in testcase-data, renamed to \"duplicate-name#1\"");
1482
1483	of_overlay_mutex_unlock();
1484
1485	return 0;
1486}
1487
1488#ifdef CONFIG_OF_OVERLAY
1489static int __init overlay_data_apply(const char *overlay_name, int *overlay_id);
1490
1491static int unittest_probe(struct platform_device *pdev)
1492{
1493	struct device *dev = &pdev->dev;
1494	struct device_node *np = dev->of_node;
1495
1496	if (np == NULL) {
1497		dev_err(dev, "No OF data for device\n");
1498		return -EINVAL;
1499
1500	}
1501
1502	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1503
1504	of_platform_populate(np, NULL, NULL, &pdev->dev);
1505
1506	return 0;
1507}
1508
1509static int unittest_remove(struct platform_device *pdev)
1510{
1511	struct device *dev = &pdev->dev;
1512	struct device_node *np = dev->of_node;
1513
1514	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1515	return 0;
1516}
1517
1518static const struct of_device_id unittest_match[] = {
1519	{ .compatible = "unittest", },
1520	{},
1521};
1522
1523static struct platform_driver unittest_driver = {
1524	.probe			= unittest_probe,
1525	.remove			= unittest_remove,
1526	.driver = {
1527		.name		= "unittest",
1528		.of_match_table	= of_match_ptr(unittest_match),
1529	},
1530};
1531
1532/* get the platform device instantiated at the path */
1533static struct platform_device *of_path_to_platform_device(const char *path)
1534{
1535	struct device_node *np;
1536	struct platform_device *pdev;
1537
1538	np = of_find_node_by_path(path);
1539	if (np == NULL)
1540		return NULL;
1541
1542	pdev = of_find_device_by_node(np);
1543	of_node_put(np);
1544
1545	return pdev;
1546}
1547
1548/* find out if a platform device exists at that path */
1549static int of_path_platform_device_exists(const char *path)
1550{
1551	struct platform_device *pdev;
1552
1553	pdev = of_path_to_platform_device(path);
1554	platform_device_put(pdev);
1555	return pdev != NULL;
1556}
1557
1558#ifdef CONFIG_OF_GPIO
1559
1560struct unittest_gpio_dev {
1561	struct gpio_chip chip;
1562};
1563
1564static int unittest_gpio_chip_request_count;
1565static int unittest_gpio_probe_count;
1566static int unittest_gpio_probe_pass_count;
1567
1568static int unittest_gpio_chip_request(struct gpio_chip *chip, unsigned int offset)
1569{
1570	unittest_gpio_chip_request_count++;
1571
1572	pr_debug("%s(): %s %d %d\n", __func__, chip->label, offset,
1573		 unittest_gpio_chip_request_count);
1574	return 0;
1575}
1576
1577static int unittest_gpio_probe(struct platform_device *pdev)
1578{
1579	struct unittest_gpio_dev *devptr;
1580	int ret;
1581
1582	unittest_gpio_probe_count++;
1583
1584	devptr = kzalloc(sizeof(*devptr), GFP_KERNEL);
1585	if (!devptr)
1586		return -ENOMEM;
1587
1588	platform_set_drvdata(pdev, devptr);
1589
1590	devptr->chip.of_node = pdev->dev.of_node;
1591	devptr->chip.label = "of-unittest-gpio";
1592	devptr->chip.base = -1; /* dynamic allocation */
1593	devptr->chip.ngpio = 5;
1594	devptr->chip.request = unittest_gpio_chip_request;
1595
1596	ret = gpiochip_add_data(&devptr->chip, NULL);
1597
1598	unittest(!ret,
1599		 "gpiochip_add_data() for node @%pOF failed, ret = %d\n", devptr->chip.of_node, ret);
1600
1601	if (!ret)
1602		unittest_gpio_probe_pass_count++;
1603	return ret;
1604}
1605
1606static int unittest_gpio_remove(struct platform_device *pdev)
1607{
1608	struct unittest_gpio_dev *gdev = platform_get_drvdata(pdev);
1609	struct device *dev = &pdev->dev;
1610	struct device_node *np = pdev->dev.of_node;
1611
1612	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1613
1614	if (!gdev)
1615		return -EINVAL;
1616
1617	if (gdev->chip.base != -1)
1618		gpiochip_remove(&gdev->chip);
1619
1620	platform_set_drvdata(pdev, NULL);
1621	kfree(gdev);
1622
1623	return 0;
1624}
1625
1626static const struct of_device_id unittest_gpio_id[] = {
1627	{ .compatible = "unittest-gpio", },
1628	{}
1629};
1630
1631static struct platform_driver unittest_gpio_driver = {
1632	.probe	= unittest_gpio_probe,
1633	.remove	= unittest_gpio_remove,
1634	.driver	= {
1635		.name		= "unittest-gpio",
1636		.of_match_table	= of_match_ptr(unittest_gpio_id),
1637	},
1638};
1639
1640static void __init of_unittest_overlay_gpio(void)
1641{
1642	int chip_request_count;
1643	int probe_pass_count;
1644	int ret;
1645
1646	/*
1647	 * tests: apply overlays before registering driver
1648	 * Similar to installing a driver as a module, the
1649	 * driver is registered after applying the overlays.
1650	 *
1651	 * The overlays are applied by overlay_data_apply()
1652	 * instead of of_unittest_apply_overlay() so that they
1653	 * will not be tracked.  Thus they will not be removed
1654	 * by of_unittest_destroy_tracked_overlays().
1655	 *
1656	 * - apply overlay_gpio_01
1657	 * - apply overlay_gpio_02a
1658	 * - apply overlay_gpio_02b
1659	 * - register driver
1660	 *
1661	 * register driver will result in
1662	 *   - probe and processing gpio hog for overlay_gpio_01
1663	 *   - probe for overlay_gpio_02a
1664	 *   - processing gpio for overlay_gpio_02b
1665	 */
1666
1667	probe_pass_count = unittest_gpio_probe_pass_count;
1668	chip_request_count = unittest_gpio_chip_request_count;
1669
1670	/*
1671	 * overlay_gpio_01 contains gpio node and child gpio hog node
1672	 * overlay_gpio_02a contains gpio node
1673	 * overlay_gpio_02b contains child gpio hog node
1674	 */
1675
1676	unittest(overlay_data_apply("overlay_gpio_01", NULL),
1677		 "Adding overlay 'overlay_gpio_01' failed\n");
1678
1679	unittest(overlay_data_apply("overlay_gpio_02a", NULL),
1680		 "Adding overlay 'overlay_gpio_02a' failed\n");
1681
1682	unittest(overlay_data_apply("overlay_gpio_02b", NULL),
1683		 "Adding overlay 'overlay_gpio_02b' failed\n");
1684
1685	/*
1686	 * messages are the result of the probes, after the
1687	 * driver is registered
1688	 */
1689
1690	EXPECT_BEGIN(KERN_INFO,
1691		     "GPIO line <<int>> (line-B-input) hogged as input\n");
1692
1693	EXPECT_BEGIN(KERN_INFO,
1694		     "GPIO line <<int>> (line-A-input) hogged as input\n");
1695
1696	ret = platform_driver_register(&unittest_gpio_driver);
1697	if (unittest(ret == 0, "could not register unittest gpio driver\n"))
1698		return;
1699
1700	EXPECT_END(KERN_INFO,
1701		   "GPIO line <<int>> (line-A-input) hogged as input\n");
1702	EXPECT_END(KERN_INFO,
1703		   "GPIO line <<int>> (line-B-input) hogged as input\n");
1704
1705	unittest(probe_pass_count + 2 == unittest_gpio_probe_pass_count,
1706		 "unittest_gpio_probe() failed or not called\n");
1707
1708	unittest(chip_request_count + 2 == unittest_gpio_chip_request_count,
1709		 "unittest_gpio_chip_request() called %d times (expected 1 time)\n",
1710		 unittest_gpio_chip_request_count - chip_request_count);
1711
1712	/*
1713	 * tests: apply overlays after registering driver
1714	 *
1715	 * Similar to a driver built-in to the kernel, the
1716	 * driver is registered before applying the overlays.
1717	 *
1718	 * overlay_gpio_03 contains gpio node and child gpio hog node
1719	 *
1720	 * - apply overlay_gpio_03
1721	 *
1722	 * apply overlay will result in
1723	 *   - probe and processing gpio hog.
1724	 */
1725
1726	probe_pass_count = unittest_gpio_probe_pass_count;
1727	chip_request_count = unittest_gpio_chip_request_count;
1728
1729	EXPECT_BEGIN(KERN_INFO,
1730		     "GPIO line <<int>> (line-D-input) hogged as input\n");
1731
1732	/* overlay_gpio_03 contains gpio node and child gpio hog node */
1733
1734	unittest(overlay_data_apply("overlay_gpio_03", NULL),
1735		 "Adding overlay 'overlay_gpio_03' failed\n");
1736
1737	EXPECT_END(KERN_INFO,
1738		   "GPIO line <<int>> (line-D-input) hogged as input\n");
1739
1740	unittest(probe_pass_count + 1 == unittest_gpio_probe_pass_count,
1741		 "unittest_gpio_probe() failed or not called\n");
1742
1743	unittest(chip_request_count + 1 == unittest_gpio_chip_request_count,
1744		 "unittest_gpio_chip_request() called %d times (expected 1 time)\n",
1745		 unittest_gpio_chip_request_count - chip_request_count);
1746
1747	/*
1748	 * overlay_gpio_04a contains gpio node
1749	 *
1750	 * - apply overlay_gpio_04a
1751	 *
1752	 * apply the overlay will result in
1753	 *   - probe for overlay_gpio_04a
1754	 */
1755
1756	probe_pass_count = unittest_gpio_probe_pass_count;
1757	chip_request_count = unittest_gpio_chip_request_count;
1758
1759	/* overlay_gpio_04a contains gpio node */
1760
1761	unittest(overlay_data_apply("overlay_gpio_04a", NULL),
1762		 "Adding overlay 'overlay_gpio_04a' failed\n");
1763
1764	unittest(probe_pass_count + 1 == unittest_gpio_probe_pass_count,
1765		 "unittest_gpio_probe() failed or not called\n");
1766
1767	/*
1768	 * overlay_gpio_04b contains child gpio hog node
1769	 *
1770	 * - apply overlay_gpio_04b
1771	 *
1772	 * apply the overlay will result in
1773	 *   - processing gpio for overlay_gpio_04b
1774	 */
1775
1776	EXPECT_BEGIN(KERN_INFO,
1777		     "GPIO line <<int>> (line-C-input) hogged as input\n");
1778
1779	/* overlay_gpio_04b contains child gpio hog node */
1780
1781	unittest(overlay_data_apply("overlay_gpio_04b", NULL),
1782		 "Adding overlay 'overlay_gpio_04b' failed\n");
1783
1784	EXPECT_END(KERN_INFO,
1785		   "GPIO line <<int>> (line-C-input) hogged as input\n");
1786
1787	unittest(chip_request_count + 1 == unittest_gpio_chip_request_count,
1788		 "unittest_gpio_chip_request() called %d times (expected 1 time)\n",
1789		 unittest_gpio_chip_request_count - chip_request_count);
1790}
1791
1792#else
1793
1794static void __init of_unittest_overlay_gpio(void)
1795{
1796	/* skip tests */
1797}
1798
1799#endif
1800
1801#if IS_BUILTIN(CONFIG_I2C)
1802
1803/* get the i2c client device instantiated at the path */
1804static struct i2c_client *of_path_to_i2c_client(const char *path)
1805{
1806	struct device_node *np;
1807	struct i2c_client *client;
1808
1809	np = of_find_node_by_path(path);
1810	if (np == NULL)
1811		return NULL;
1812
1813	client = of_find_i2c_device_by_node(np);
1814	of_node_put(np);
1815
1816	return client;
1817}
1818
1819/* find out if a i2c client device exists at that path */
1820static int of_path_i2c_client_exists(const char *path)
1821{
1822	struct i2c_client *client;
1823
1824	client = of_path_to_i2c_client(path);
1825	if (client)
1826		put_device(&client->dev);
1827	return client != NULL;
1828}
1829#else
1830static int of_path_i2c_client_exists(const char *path)
1831{
1832	return 0;
1833}
1834#endif
1835
1836enum overlay_type {
1837	PDEV_OVERLAY,
1838	I2C_OVERLAY
1839};
1840
1841static int of_path_device_type_exists(const char *path,
1842		enum overlay_type ovtype)
1843{
1844	switch (ovtype) {
1845	case PDEV_OVERLAY:
1846		return of_path_platform_device_exists(path);
1847	case I2C_OVERLAY:
1848		return of_path_i2c_client_exists(path);
1849	}
1850	return 0;
1851}
1852
1853static const char *unittest_path(int nr, enum overlay_type ovtype)
1854{
1855	const char *base;
1856	static char buf[256];
1857
1858	switch (ovtype) {
1859	case PDEV_OVERLAY:
1860		base = "/testcase-data/overlay-node/test-bus";
1861		break;
1862	case I2C_OVERLAY:
1863		base = "/testcase-data/overlay-node/test-bus/i2c-test-bus";
1864		break;
1865	default:
1866		buf[0] = '\0';
1867		return buf;
1868	}
1869	snprintf(buf, sizeof(buf) - 1, "%s/test-unittest%d", base, nr);
1870	buf[sizeof(buf) - 1] = '\0';
1871	return buf;
1872}
1873
1874static int of_unittest_device_exists(int unittest_nr, enum overlay_type ovtype)
1875{
1876	const char *path;
1877
1878	path = unittest_path(unittest_nr, ovtype);
1879
1880	switch (ovtype) {
1881	case PDEV_OVERLAY:
1882		return of_path_platform_device_exists(path);
1883	case I2C_OVERLAY:
1884		return of_path_i2c_client_exists(path);
1885	}
1886	return 0;
1887}
1888
1889static const char *overlay_name_from_nr(int nr)
1890{
1891	static char buf[256];
1892
1893	snprintf(buf, sizeof(buf) - 1,
1894		"overlay_%d", nr);
1895	buf[sizeof(buf) - 1] = '\0';
1896
1897	return buf;
1898}
1899
1900static const char *bus_path = "/testcase-data/overlay-node/test-bus";
1901
1902/* FIXME: it is NOT guaranteed that overlay ids are assigned in sequence */
1903
1904#define MAX_UNITTEST_OVERLAYS	256
1905static unsigned long overlay_id_bits[BITS_TO_LONGS(MAX_UNITTEST_OVERLAYS)];
1906static int overlay_first_id = -1;
1907
1908static long of_unittest_overlay_tracked(int id)
1909{
1910	if (WARN_ON(id >= MAX_UNITTEST_OVERLAYS))
1911		return 0;
1912	return overlay_id_bits[BIT_WORD(id)] & BIT_MASK(id);
1913}
1914
1915static void of_unittest_track_overlay(int id)
1916{
1917	if (overlay_first_id < 0)
1918		overlay_first_id = id;
1919	id -= overlay_first_id;
1920
1921	if (WARN_ON(id >= MAX_UNITTEST_OVERLAYS))
1922		return;
1923	overlay_id_bits[BIT_WORD(id)] |= BIT_MASK(id);
1924}
1925
1926static void of_unittest_untrack_overlay(int id)
1927{
1928	if (overlay_first_id < 0)
1929		return;
1930	id -= overlay_first_id;
1931	if (WARN_ON(id >= MAX_UNITTEST_OVERLAYS))
1932		return;
1933	overlay_id_bits[BIT_WORD(id)] &= ~BIT_MASK(id);
1934}
1935
1936static void of_unittest_destroy_tracked_overlays(void)
1937{
1938	int id, ret, defers, ovcs_id;
1939
1940	if (overlay_first_id < 0)
1941		return;
1942
1943	/* try until no defers */
1944	do {
1945		defers = 0;
1946		/* remove in reverse order */
1947		for (id = MAX_UNITTEST_OVERLAYS - 1; id >= 0; id--) {
1948			if (!of_unittest_overlay_tracked(id))
1949				continue;
1950
1951			ovcs_id = id + overlay_first_id;
1952			ret = of_overlay_remove(&ovcs_id);
1953			if (ret == -ENODEV) {
1954				pr_warn("%s: no overlay to destroy for #%d\n",
1955					__func__, id + overlay_first_id);
1956				continue;
1957			}
1958			if (ret != 0) {
1959				defers++;
1960				pr_warn("%s: overlay destroy failed for #%d\n",
1961					__func__, id + overlay_first_id);
1962				continue;
1963			}
1964
1965			of_unittest_untrack_overlay(id);
1966		}
1967	} while (defers > 0);
1968}
1969
1970static int __init of_unittest_apply_overlay(int overlay_nr, int *overlay_id)
1971{
1972	const char *overlay_name;
1973
1974	overlay_name = overlay_name_from_nr(overlay_nr);
1975
1976	if (!overlay_data_apply(overlay_name, overlay_id)) {
1977		unittest(0, "could not apply overlay \"%s\"\n",
1978				overlay_name);
1979		return -EFAULT;
1980	}
1981	of_unittest_track_overlay(*overlay_id);
1982
1983	return 0;
1984}
1985
1986/* apply an overlay while checking before and after states */
1987static int __init of_unittest_apply_overlay_check(int overlay_nr,
1988		int unittest_nr, int before, int after,
1989		enum overlay_type ovtype)
1990{
1991	int ret, ovcs_id;
1992
1993	/* unittest device must not be in before state */
1994	if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
1995		unittest(0, "%s with device @\"%s\" %s\n",
1996				overlay_name_from_nr(overlay_nr),
1997				unittest_path(unittest_nr, ovtype),
1998				!before ? "enabled" : "disabled");
1999		return -EINVAL;
2000	}
2001
2002	ovcs_id = 0;
2003	ret = of_unittest_apply_overlay(overlay_nr, &ovcs_id);
2004	if (ret != 0) {
2005		/* of_unittest_apply_overlay already called unittest() */
2006		return ret;
2007	}
2008
2009	/* unittest device must be to set to after state */
2010	if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
2011		unittest(0, "%s failed to create @\"%s\" %s\n",
2012				overlay_name_from_nr(overlay_nr),
2013				unittest_path(unittest_nr, ovtype),
2014				!after ? "enabled" : "disabled");
2015		return -EINVAL;
2016	}
2017
2018	return 0;
2019}
2020
2021/* apply an overlay and then revert it while checking before, after states */
2022static int __init of_unittest_apply_revert_overlay_check(int overlay_nr,
2023		int unittest_nr, int before, int after,
2024		enum overlay_type ovtype)
2025{
2026	int ret, ovcs_id, save_id;
2027
2028	/* unittest device must be in before state */
2029	if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
2030		unittest(0, "%s with device @\"%s\" %s\n",
2031				overlay_name_from_nr(overlay_nr),
2032				unittest_path(unittest_nr, ovtype),
2033				!before ? "enabled" : "disabled");
2034		return -EINVAL;
2035	}
2036
2037	/* apply the overlay */
2038	ovcs_id = 0;
2039	ret = of_unittest_apply_overlay(overlay_nr, &ovcs_id);
2040	if (ret != 0) {
2041		/* of_unittest_apply_overlay already called unittest() */
2042		return ret;
2043	}
2044
2045	/* unittest device must be in after state */
2046	if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
2047		unittest(0, "%s failed to create @\"%s\" %s\n",
2048				overlay_name_from_nr(overlay_nr),
2049				unittest_path(unittest_nr, ovtype),
2050				!after ? "enabled" : "disabled");
2051		return -EINVAL;
2052	}
2053
2054	save_id = ovcs_id;
2055	ret = of_overlay_remove(&ovcs_id);
2056	if (ret != 0) {
2057		unittest(0, "%s failed to be destroyed @\"%s\"\n",
2058				overlay_name_from_nr(overlay_nr),
2059				unittest_path(unittest_nr, ovtype));
2060		return ret;
2061	}
2062	of_unittest_untrack_overlay(save_id);
2063
2064	/* unittest device must be again in before state */
2065	if (of_unittest_device_exists(unittest_nr, PDEV_OVERLAY) != before) {
2066		unittest(0, "%s with device @\"%s\" %s\n",
2067				overlay_name_from_nr(overlay_nr),
2068				unittest_path(unittest_nr, ovtype),
2069				!before ? "enabled" : "disabled");
2070		return -EINVAL;
2071	}
2072
2073	return 0;
2074}
2075
2076/* test activation of device */
2077static void __init of_unittest_overlay_0(void)
2078{
2079	int ret;
2080
2081	EXPECT_BEGIN(KERN_INFO,
2082		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest0/status");
2083
2084	/* device should enable */
2085	ret = of_unittest_apply_overlay_check(0, 0, 0, 1, PDEV_OVERLAY);
2086
2087	EXPECT_END(KERN_INFO,
2088		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest0/status");
2089
2090	if (ret)
2091		return;
2092
2093	unittest(1, "overlay test %d passed\n", 0);
2094}
2095
2096/* test deactivation of device */
2097static void __init of_unittest_overlay_1(void)
2098{
2099	int ret;
2100
2101	EXPECT_BEGIN(KERN_INFO,
2102		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest1/status");
2103
2104	/* device should disable */
2105	ret = of_unittest_apply_overlay_check(1, 1, 1, 0, PDEV_OVERLAY);
2106
2107	EXPECT_END(KERN_INFO,
2108		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest1/status");
2109
2110	if (ret)
2111		return;
2112
2113	unittest(1, "overlay test %d passed\n", 1);
2114
2115}
2116
2117/* test activation of device */
2118static void __init of_unittest_overlay_2(void)
2119{
2120	int ret;
2121
2122	EXPECT_BEGIN(KERN_INFO,
2123		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest2/status");
2124
2125	/* device should enable */
2126	ret = of_unittest_apply_overlay_check(2, 2, 0, 1, PDEV_OVERLAY);
2127
2128	EXPECT_END(KERN_INFO,
2129		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest2/status");
2130
2131	if (ret)
2132		return;
2133	unittest(1, "overlay test %d passed\n", 2);
2134}
2135
2136/* test deactivation of device */
2137static void __init of_unittest_overlay_3(void)
2138{
2139	int ret;
2140
2141	EXPECT_BEGIN(KERN_INFO,
2142		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest3/status");
2143
2144	/* device should disable */
2145	ret = of_unittest_apply_overlay_check(3, 3, 1, 0, PDEV_OVERLAY);
2146
2147	EXPECT_END(KERN_INFO,
2148		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest3/status");
2149
2150	if (ret)
2151		return;
2152
2153	unittest(1, "overlay test %d passed\n", 3);
2154}
2155
2156/* test activation of a full device node */
2157static void __init of_unittest_overlay_4(void)
2158{
2159	/* device should disable */
2160	if (of_unittest_apply_overlay_check(4, 4, 0, 1, PDEV_OVERLAY))
2161		return;
2162
2163	unittest(1, "overlay test %d passed\n", 4);
2164}
2165
2166/* test overlay apply/revert sequence */
2167static void __init of_unittest_overlay_5(void)
2168{
2169	int ret;
2170
2171	EXPECT_BEGIN(KERN_INFO,
2172		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest5/status");
2173
2174	/* device should disable */
2175	ret = of_unittest_apply_revert_overlay_check(5, 5, 0, 1, PDEV_OVERLAY);
2176
2177	EXPECT_END(KERN_INFO,
2178		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest5/status");
2179
2180	if (ret)
2181		return;
2182
2183	unittest(1, "overlay test %d passed\n", 5);
2184}
2185
2186/* test overlay application in sequence */
2187static void __init of_unittest_overlay_6(void)
2188{
2189	int i, ov_id[2], ovcs_id;
2190	int overlay_nr = 6, unittest_nr = 6;
2191	int before = 0, after = 1;
2192	const char *overlay_name;
2193
2194	int ret;
2195
2196	/* unittest device must be in before state */
2197	for (i = 0; i < 2; i++) {
2198		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
2199				!= before) {
2200			unittest(0, "%s with device @\"%s\" %s\n",
2201					overlay_name_from_nr(overlay_nr + i),
2202					unittest_path(unittest_nr + i,
2203						PDEV_OVERLAY),
2204					!before ? "enabled" : "disabled");
2205			return;
2206		}
2207	}
2208
2209	/* apply the overlays */
2210
2211	EXPECT_BEGIN(KERN_INFO,
2212		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest6/status");
2213
2214	overlay_name = overlay_name_from_nr(overlay_nr + 0);
2215
2216	ret = overlay_data_apply(overlay_name, &ovcs_id);
2217
2218	if (!ret) {
2219		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2220			return;
2221	}
2222	ov_id[0] = ovcs_id;
2223	of_unittest_track_overlay(ov_id[0]);
2224
2225	EXPECT_END(KERN_INFO,
2226		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest6/status");
2227
2228	EXPECT_BEGIN(KERN_INFO,
2229		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest7/status");
2230
2231	overlay_name = overlay_name_from_nr(overlay_nr + 1);
2232
2233	ret = overlay_data_apply(overlay_name, &ovcs_id);
2234
2235	if (!ret) {
2236		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2237			return;
2238	}
2239	ov_id[1] = ovcs_id;
2240	of_unittest_track_overlay(ov_id[1]);
2241
2242	EXPECT_END(KERN_INFO,
2243		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest7/status");
2244
2245
2246	for (i = 0; i < 2; i++) {
2247		/* unittest device must be in after state */
2248		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
2249				!= after) {
2250			unittest(0, "overlay @\"%s\" failed @\"%s\" %s\n",
2251					overlay_name_from_nr(overlay_nr + i),
2252					unittest_path(unittest_nr + i,
2253						PDEV_OVERLAY),
2254					!after ? "enabled" : "disabled");
2255			return;
2256		}
2257	}
2258
2259	for (i = 1; i >= 0; i--) {
2260		ovcs_id = ov_id[i];
2261		if (of_overlay_remove(&ovcs_id)) {
2262			unittest(0, "%s failed destroy @\"%s\"\n",
2263					overlay_name_from_nr(overlay_nr + i),
2264					unittest_path(unittest_nr + i,
2265						PDEV_OVERLAY));
2266			return;
2267		}
2268		of_unittest_untrack_overlay(ov_id[i]);
2269	}
2270
2271	for (i = 0; i < 2; i++) {
2272		/* unittest device must be again in before state */
2273		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
2274				!= before) {
2275			unittest(0, "%s with device @\"%s\" %s\n",
2276					overlay_name_from_nr(overlay_nr + i),
2277					unittest_path(unittest_nr + i,
2278						PDEV_OVERLAY),
2279					!before ? "enabled" : "disabled");
2280			return;
2281		}
2282	}
2283
2284	unittest(1, "overlay test %d passed\n", 6);
2285
2286}
2287
2288/* test overlay application in sequence */
2289static void __init of_unittest_overlay_8(void)
2290{
2291	int i, ov_id[2], ovcs_id;
2292	int overlay_nr = 8, unittest_nr = 8;
2293	const char *overlay_name;
2294	int ret;
2295
2296	/* we don't care about device state in this test */
2297
2298	EXPECT_BEGIN(KERN_INFO,
2299		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/status");
2300
2301	overlay_name = overlay_name_from_nr(overlay_nr + 0);
2302
2303	ret = overlay_data_apply(overlay_name, &ovcs_id);
2304	if (!ret)
2305		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2306
2307	EXPECT_END(KERN_INFO,
2308		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/status");
2309
2310	if (!ret)
2311		return;
2312
2313	ov_id[0] = ovcs_id;
2314	of_unittest_track_overlay(ov_id[0]);
2315
2316	overlay_name = overlay_name_from_nr(overlay_nr + 1);
2317
2318	EXPECT_BEGIN(KERN_INFO,
2319		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/property-foo");
2320
2321	/* apply the overlays */
2322	ret = overlay_data_apply(overlay_name, &ovcs_id);
2323
2324	EXPECT_END(KERN_INFO,
2325		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/property-foo");
2326
2327	if (!ret) {
2328		unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
2329		return;
2330	}
2331
2332	ov_id[1] = ovcs_id;
2333	of_unittest_track_overlay(ov_id[1]);
2334
2335	/* now try to remove first overlay (it should fail) */
2336	ovcs_id = ov_id[0];
2337
2338	EXPECT_BEGIN(KERN_INFO,
2339		     "OF: overlay: node_overlaps_later_cs: #6 overlaps with #7 @/testcase-data/overlay-node/test-bus/test-unittest8");
2340
2341	EXPECT_BEGIN(KERN_INFO,
2342		     "OF: overlay: overlay #6 is not topmost");
2343
2344	ret = of_overlay_remove(&ovcs_id);
2345
2346	EXPECT_END(KERN_INFO,
2347		   "OF: overlay: overlay #6 is not topmost");
2348
2349	EXPECT_END(KERN_INFO,
2350		   "OF: overlay: node_overlaps_later_cs: #6 overlaps with #7 @/testcase-data/overlay-node/test-bus/test-unittest8");
2351
2352	if (!ret) {
2353		unittest(0, "%s was destroyed @\"%s\"\n",
2354				overlay_name_from_nr(overlay_nr + 0),
2355				unittest_path(unittest_nr,
2356					PDEV_OVERLAY));
2357		return;
2358	}
2359
2360	/* removing them in order should work */
2361	for (i = 1; i >= 0; i--) {
2362		ovcs_id = ov_id[i];
2363		if (of_overlay_remove(&ovcs_id)) {
2364			unittest(0, "%s not destroyed @\"%s\"\n",
2365					overlay_name_from_nr(overlay_nr + i),
2366					unittest_path(unittest_nr,
2367						PDEV_OVERLAY));
2368			return;
2369		}
2370		of_unittest_untrack_overlay(ov_id[i]);
2371	}
2372
2373	unittest(1, "overlay test %d passed\n", 8);
2374}
2375
2376/* test insertion of a bus with parent devices */
2377static void __init of_unittest_overlay_10(void)
2378{
2379	int ret;
2380	char *child_path;
2381
2382	/* device should disable */
2383	ret = of_unittest_apply_overlay_check(10, 10, 0, 1, PDEV_OVERLAY);
2384
2385	if (unittest(ret == 0,
2386			"overlay test %d failed; overlay application\n", 10))
2387		return;
2388
2389	child_path = kasprintf(GFP_KERNEL, "%s/test-unittest101",
2390			unittest_path(10, PDEV_OVERLAY));
2391	if (unittest(child_path, "overlay test %d failed; kasprintf\n", 10))
2392		return;
2393
2394	ret = of_path_device_type_exists(child_path, PDEV_OVERLAY);
2395	kfree(child_path);
2396
2397	unittest(ret, "overlay test %d failed; no child device\n", 10);
2398}
2399
2400/* test insertion of a bus with parent devices (and revert) */
2401static void __init of_unittest_overlay_11(void)
2402{
2403	int ret;
2404
2405	/* device should disable */
2406	ret = of_unittest_apply_revert_overlay_check(11, 11, 0, 1,
2407			PDEV_OVERLAY);
2408
2409	unittest(ret == 0, "overlay test %d failed; overlay apply\n", 11);
2410}
2411
2412#if IS_BUILTIN(CONFIG_I2C) && IS_ENABLED(CONFIG_OF_OVERLAY)
2413
2414struct unittest_i2c_bus_data {
2415	struct platform_device	*pdev;
2416	struct i2c_adapter	adap;
2417};
2418
2419static int unittest_i2c_master_xfer(struct i2c_adapter *adap,
2420		struct i2c_msg *msgs, int num)
2421{
2422	struct unittest_i2c_bus_data *std = i2c_get_adapdata(adap);
2423
2424	(void)std;
2425
2426	return num;
2427}
2428
2429static u32 unittest_i2c_functionality(struct i2c_adapter *adap)
2430{
2431	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
2432}
2433
2434static const struct i2c_algorithm unittest_i2c_algo = {
2435	.master_xfer	= unittest_i2c_master_xfer,
2436	.functionality	= unittest_i2c_functionality,
2437};
2438
2439static int unittest_i2c_bus_probe(struct platform_device *pdev)
2440{
2441	struct device *dev = &pdev->dev;
2442	struct device_node *np = dev->of_node;
2443	struct unittest_i2c_bus_data *std;
2444	struct i2c_adapter *adap;
2445	int ret;
2446
2447	if (np == NULL) {
2448		dev_err(dev, "No OF data for device\n");
2449		return -EINVAL;
2450
2451	}
2452
2453	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2454
2455	std = devm_kzalloc(dev, sizeof(*std), GFP_KERNEL);
2456	if (!std)
2457		return -ENOMEM;
2458
2459	/* link them together */
2460	std->pdev = pdev;
2461	platform_set_drvdata(pdev, std);
2462
2463	adap = &std->adap;
2464	i2c_set_adapdata(adap, std);
2465	adap->nr = -1;
2466	strlcpy(adap->name, pdev->name, sizeof(adap->name));
2467	adap->class = I2C_CLASS_DEPRECATED;
2468	adap->algo = &unittest_i2c_algo;
2469	adap->dev.parent = dev;
2470	adap->dev.of_node = dev->of_node;
2471	adap->timeout = 5 * HZ;
2472	adap->retries = 3;
2473
2474	ret = i2c_add_numbered_adapter(adap);
2475	if (ret != 0) {
2476		dev_err(dev, "Failed to add I2C adapter\n");
2477		return ret;
2478	}
2479
2480	return 0;
2481}
2482
2483static int unittest_i2c_bus_remove(struct platform_device *pdev)
2484{
2485	struct device *dev = &pdev->dev;
2486	struct device_node *np = dev->of_node;
2487	struct unittest_i2c_bus_data *std = platform_get_drvdata(pdev);
2488
2489	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2490	i2c_del_adapter(&std->adap);
2491
2492	return 0;
2493}
2494
2495static const struct of_device_id unittest_i2c_bus_match[] = {
2496	{ .compatible = "unittest-i2c-bus", },
2497	{},
2498};
2499
2500static struct platform_driver unittest_i2c_bus_driver = {
2501	.probe			= unittest_i2c_bus_probe,
2502	.remove			= unittest_i2c_bus_remove,
2503	.driver = {
2504		.name		= "unittest-i2c-bus",
2505		.of_match_table	= of_match_ptr(unittest_i2c_bus_match),
2506	},
2507};
2508
2509static int unittest_i2c_dev_probe(struct i2c_client *client,
2510		const struct i2c_device_id *id)
2511{
2512	struct device *dev = &client->dev;
2513	struct device_node *np = client->dev.of_node;
2514
2515	if (!np) {
2516		dev_err(dev, "No OF node\n");
2517		return -EINVAL;
2518	}
2519
2520	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2521
2522	return 0;
2523};
2524
2525static int unittest_i2c_dev_remove(struct i2c_client *client)
2526{
2527	struct device *dev = &client->dev;
2528	struct device_node *np = client->dev.of_node;
2529
2530	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2531	return 0;
2532}
2533
2534static const struct i2c_device_id unittest_i2c_dev_id[] = {
2535	{ .name = "unittest-i2c-dev" },
2536	{ }
2537};
2538
2539static struct i2c_driver unittest_i2c_dev_driver = {
2540	.driver = {
2541		.name = "unittest-i2c-dev",
2542	},
2543	.probe = unittest_i2c_dev_probe,
2544	.remove = unittest_i2c_dev_remove,
2545	.id_table = unittest_i2c_dev_id,
2546};
2547
2548#if IS_BUILTIN(CONFIG_I2C_MUX)
2549
2550static int unittest_i2c_mux_select_chan(struct i2c_mux_core *muxc, u32 chan)
2551{
2552	return 0;
2553}
2554
2555static int unittest_i2c_mux_probe(struct i2c_client *client,
2556		const struct i2c_device_id *id)
2557{
2558	int i, nchans;
2559	struct device *dev = &client->dev;
2560	struct i2c_adapter *adap = client->adapter;
2561	struct device_node *np = client->dev.of_node, *child;
2562	struct i2c_mux_core *muxc;
2563	u32 reg, max_reg;
2564
2565	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2566
2567	if (!np) {
2568		dev_err(dev, "No OF node\n");
2569		return -EINVAL;
2570	}
2571
2572	max_reg = (u32)-1;
2573	for_each_child_of_node(np, child) {
2574		if (of_property_read_u32(child, "reg", &reg))
2575			continue;
2576		if (max_reg == (u32)-1 || reg > max_reg)
2577			max_reg = reg;
2578	}
2579	nchans = max_reg == (u32)-1 ? 0 : max_reg + 1;
2580	if (nchans == 0) {
2581		dev_err(dev, "No channels\n");
2582		return -EINVAL;
2583	}
2584
2585	muxc = i2c_mux_alloc(adap, dev, nchans, 0, 0,
2586			     unittest_i2c_mux_select_chan, NULL);
2587	if (!muxc)
2588		return -ENOMEM;
2589	for (i = 0; i < nchans; i++) {
2590		if (i2c_mux_add_adapter(muxc, 0, i, 0)) {
2591			dev_err(dev, "Failed to register mux #%d\n", i);
2592			i2c_mux_del_adapters(muxc);
2593			return -ENODEV;
2594		}
2595	}
2596
2597	i2c_set_clientdata(client, muxc);
2598
2599	return 0;
2600};
2601
2602static int unittest_i2c_mux_remove(struct i2c_client *client)
2603{
2604	struct device *dev = &client->dev;
2605	struct device_node *np = client->dev.of_node;
2606	struct i2c_mux_core *muxc = i2c_get_clientdata(client);
2607
2608	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
2609	i2c_mux_del_adapters(muxc);
2610	return 0;
2611}
2612
2613static const struct i2c_device_id unittest_i2c_mux_id[] = {
2614	{ .name = "unittest-i2c-mux" },
2615	{ }
2616};
2617
2618static struct i2c_driver unittest_i2c_mux_driver = {
2619	.driver = {
2620		.name = "unittest-i2c-mux",
2621	},
2622	.probe = unittest_i2c_mux_probe,
2623	.remove = unittest_i2c_mux_remove,
2624	.id_table = unittest_i2c_mux_id,
2625};
2626
2627#endif
2628
2629static int of_unittest_overlay_i2c_init(void)
2630{
2631	int ret;
2632
2633	ret = i2c_add_driver(&unittest_i2c_dev_driver);
2634	if (unittest(ret == 0,
2635			"could not register unittest i2c device driver\n"))
2636		return ret;
2637
2638	ret = platform_driver_register(&unittest_i2c_bus_driver);
2639
2640	if (unittest(ret == 0,
2641			"could not register unittest i2c bus driver\n"))
2642		return ret;
2643
2644#if IS_BUILTIN(CONFIG_I2C_MUX)
2645
2646	EXPECT_BEGIN(KERN_INFO,
2647		     "i2c i2c-1: Added multiplexed i2c bus 2");
2648
2649	ret = i2c_add_driver(&unittest_i2c_mux_driver);
2650
2651	EXPECT_END(KERN_INFO,
2652		   "i2c i2c-1: Added multiplexed i2c bus 2");
2653
2654	if (unittest(ret == 0,
2655			"could not register unittest i2c mux driver\n"))
2656		return ret;
2657#endif
2658
2659	return 0;
2660}
2661
2662static void of_unittest_overlay_i2c_cleanup(void)
2663{
2664#if IS_BUILTIN(CONFIG_I2C_MUX)
2665	i2c_del_driver(&unittest_i2c_mux_driver);
2666#endif
2667	platform_driver_unregister(&unittest_i2c_bus_driver);
2668	i2c_del_driver(&unittest_i2c_dev_driver);
2669}
2670
2671static void __init of_unittest_overlay_i2c_12(void)
2672{
2673	int ret;
2674
2675	/* device should enable */
2676	EXPECT_BEGIN(KERN_INFO,
2677		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest12/status");
2678
2679	ret = of_unittest_apply_overlay_check(12, 12, 0, 1, I2C_OVERLAY);
2680
2681	EXPECT_END(KERN_INFO,
2682		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest12/status");
2683
2684	if (ret)
2685		return;
2686
2687	unittest(1, "overlay test %d passed\n", 12);
2688}
2689
2690/* test deactivation of device */
2691static void __init of_unittest_overlay_i2c_13(void)
2692{
2693	int ret;
2694
2695	EXPECT_BEGIN(KERN_INFO,
2696		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest13/status");
2697
2698	/* device should disable */
2699	ret = of_unittest_apply_overlay_check(13, 13, 1, 0, I2C_OVERLAY);
2700
2701	EXPECT_END(KERN_INFO,
2702		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest13/status");
2703
2704	if (ret)
2705		return;
2706
2707	unittest(1, "overlay test %d passed\n", 13);
2708}
2709
2710/* just check for i2c mux existence */
2711static void of_unittest_overlay_i2c_14(void)
2712{
2713}
2714
2715static void __init of_unittest_overlay_i2c_15(void)
2716{
2717	int ret;
2718
2719	/* device should enable */
2720	EXPECT_BEGIN(KERN_INFO,
2721		     "i2c i2c-1: Added multiplexed i2c bus 3");
2722
2723	ret = of_unittest_apply_overlay_check(15, 15, 0, 1, I2C_OVERLAY);
2724
2725	EXPECT_END(KERN_INFO,
2726		   "i2c i2c-1: Added multiplexed i2c bus 3");
2727
2728	if (ret)
2729		return;
2730
2731	unittest(1, "overlay test %d passed\n", 15);
2732}
2733
2734#else
2735
2736static inline void of_unittest_overlay_i2c_14(void) { }
2737static inline void of_unittest_overlay_i2c_15(void) { }
2738
2739#endif
2740
2741static void __init of_unittest_overlay(void)
2742{
2743	struct device_node *bus_np = NULL;
2744
2745	if (platform_driver_register(&unittest_driver)) {
2746		unittest(0, "could not register unittest driver\n");
2747		goto out;
2748	}
2749
2750	bus_np = of_find_node_by_path(bus_path);
2751	if (bus_np == NULL) {
2752		unittest(0, "could not find bus_path \"%s\"\n", bus_path);
2753		goto out;
2754	}
2755
2756	if (of_platform_default_populate(bus_np, NULL, NULL)) {
2757		unittest(0, "could not populate bus @ \"%s\"\n", bus_path);
2758		goto out;
2759	}
2760
2761	if (!of_unittest_device_exists(100, PDEV_OVERLAY)) {
2762		unittest(0, "could not find unittest0 @ \"%s\"\n",
2763				unittest_path(100, PDEV_OVERLAY));
2764		goto out;
2765	}
2766
2767	if (of_unittest_device_exists(101, PDEV_OVERLAY)) {
2768		unittest(0, "unittest1 @ \"%s\" should not exist\n",
2769				unittest_path(101, PDEV_OVERLAY));
2770		goto out;
2771	}
2772
2773	unittest(1, "basic infrastructure of overlays passed");
2774
2775	/* tests in sequence */
2776	of_unittest_overlay_0();
2777	of_unittest_overlay_1();
2778	of_unittest_overlay_2();
2779	of_unittest_overlay_3();
2780	of_unittest_overlay_4();
2781	of_unittest_overlay_5();
2782	of_unittest_overlay_6();
2783	of_unittest_overlay_8();
2784
2785	of_unittest_overlay_10();
2786	of_unittest_overlay_11();
2787
2788#if IS_BUILTIN(CONFIG_I2C)
2789	if (unittest(of_unittest_overlay_i2c_init() == 0, "i2c init failed\n"))
2790		goto out;
2791
2792	of_unittest_overlay_i2c_12();
2793	of_unittest_overlay_i2c_13();
2794	of_unittest_overlay_i2c_14();
2795	of_unittest_overlay_i2c_15();
2796
2797	of_unittest_overlay_i2c_cleanup();
2798#endif
2799
2800	of_unittest_overlay_gpio();
2801
2802	of_unittest_destroy_tracked_overlays();
2803
2804out:
2805	of_node_put(bus_np);
2806}
2807
2808#else
2809static inline void __init of_unittest_overlay(void) { }
2810#endif
2811
2812#ifdef CONFIG_OF_OVERLAY
2813
2814/*
2815 * __dtb_ot_begin[] and __dtb_ot_end[] are created by cmd_dt_S_dtb
2816 * in scripts/Makefile.lib
2817 */
2818
2819#define OVERLAY_INFO_EXTERN(name) \
2820	extern uint8_t __dtb_##name##_begin[]; \
2821	extern uint8_t __dtb_##name##_end[]
2822
2823#define OVERLAY_INFO(overlay_name, expected)             \
2824{	.dtb_begin       = __dtb_##overlay_name##_begin, \
2825	.dtb_end         = __dtb_##overlay_name##_end,   \
2826	.expected_result = expected,                     \
2827	.name            = #overlay_name,                \
2828}
2829
2830struct overlay_info {
2831	uint8_t		*dtb_begin;
2832	uint8_t		*dtb_end;
2833	int		expected_result;
2834	int		overlay_id;
2835	char		*name;
2836};
2837
2838OVERLAY_INFO_EXTERN(overlay_base);
2839OVERLAY_INFO_EXTERN(overlay);
2840OVERLAY_INFO_EXTERN(overlay_0);
2841OVERLAY_INFO_EXTERN(overlay_1);
2842OVERLAY_INFO_EXTERN(overlay_2);
2843OVERLAY_INFO_EXTERN(overlay_3);
2844OVERLAY_INFO_EXTERN(overlay_4);
2845OVERLAY_INFO_EXTERN(overlay_5);
2846OVERLAY_INFO_EXTERN(overlay_6);
2847OVERLAY_INFO_EXTERN(overlay_7);
2848OVERLAY_INFO_EXTERN(overlay_8);
2849OVERLAY_INFO_EXTERN(overlay_9);
2850OVERLAY_INFO_EXTERN(overlay_10);
2851OVERLAY_INFO_EXTERN(overlay_11);
2852OVERLAY_INFO_EXTERN(overlay_12);
2853OVERLAY_INFO_EXTERN(overlay_13);
2854OVERLAY_INFO_EXTERN(overlay_15);
2855OVERLAY_INFO_EXTERN(overlay_gpio_01);
2856OVERLAY_INFO_EXTERN(overlay_gpio_02a);
2857OVERLAY_INFO_EXTERN(overlay_gpio_02b);
2858OVERLAY_INFO_EXTERN(overlay_gpio_03);
2859OVERLAY_INFO_EXTERN(overlay_gpio_04a);
2860OVERLAY_INFO_EXTERN(overlay_gpio_04b);
2861OVERLAY_INFO_EXTERN(overlay_bad_add_dup_node);
2862OVERLAY_INFO_EXTERN(overlay_bad_add_dup_prop);
2863OVERLAY_INFO_EXTERN(overlay_bad_phandle);
2864OVERLAY_INFO_EXTERN(overlay_bad_symbol);
2865
2866/* entries found by name */
2867static struct overlay_info overlays[] = {
2868	OVERLAY_INFO(overlay_base, -9999),
2869	OVERLAY_INFO(overlay, 0),
2870	OVERLAY_INFO(overlay_0, 0),
2871	OVERLAY_INFO(overlay_1, 0),
2872	OVERLAY_INFO(overlay_2, 0),
2873	OVERLAY_INFO(overlay_3, 0),
2874	OVERLAY_INFO(overlay_4, 0),
2875	OVERLAY_INFO(overlay_5, 0),
2876	OVERLAY_INFO(overlay_6, 0),
2877	OVERLAY_INFO(overlay_7, 0),
2878	OVERLAY_INFO(overlay_8, 0),
2879	OVERLAY_INFO(overlay_9, 0),
2880	OVERLAY_INFO(overlay_10, 0),
2881	OVERLAY_INFO(overlay_11, 0),
2882	OVERLAY_INFO(overlay_12, 0),
2883	OVERLAY_INFO(overlay_13, 0),
2884	OVERLAY_INFO(overlay_15, 0),
2885	OVERLAY_INFO(overlay_gpio_01, 0),
2886	OVERLAY_INFO(overlay_gpio_02a, 0),
2887	OVERLAY_INFO(overlay_gpio_02b, 0),
2888	OVERLAY_INFO(overlay_gpio_03, 0),
2889	OVERLAY_INFO(overlay_gpio_04a, 0),
2890	OVERLAY_INFO(overlay_gpio_04b, 0),
2891	OVERLAY_INFO(overlay_bad_add_dup_node, -EINVAL),
2892	OVERLAY_INFO(overlay_bad_add_dup_prop, -EINVAL),
2893	OVERLAY_INFO(overlay_bad_phandle, -EINVAL),
2894	OVERLAY_INFO(overlay_bad_symbol, -EINVAL),
2895	/* end marker */
2896	{.dtb_begin = NULL, .dtb_end = NULL, .expected_result = 0, .name = NULL}
2897};
2898
2899static struct device_node *overlay_base_root;
2900
2901static void * __init dt_alloc_memory(u64 size, u64 align)
2902{
2903	void *ptr = memblock_alloc(size, align);
2904
2905	if (!ptr)
2906		panic("%s: Failed to allocate %llu bytes align=0x%llx\n",
2907		      __func__, size, align);
2908
2909	return ptr;
2910}
2911
2912/*
2913 * Create base device tree for the overlay unittest.
2914 *
2915 * This is called from very early boot code.
2916 *
2917 * Do as much as possible the same way as done in __unflatten_device_tree
2918 * and other early boot steps for the normal FDT so that the overlay base
2919 * unflattened tree will have the same characteristics as the real tree
2920 * (such as having memory allocated by the early allocator).  The goal
2921 * is to test "the real thing" as much as possible, and test "test setup
2922 * code" as little as possible.
2923 *
2924 * Have to stop before resolving phandles, because that uses kmalloc.
2925 */
2926void __init unittest_unflatten_overlay_base(void)
2927{
2928	struct overlay_info *info;
2929	u32 data_size;
2930	void *new_fdt;
2931	u32 size;
2932	int found = 0;
2933	const char *overlay_name = "overlay_base";
2934
2935	for (info = overlays; info && info->name; info++) {
2936		if (!strcmp(overlay_name, info->name)) {
2937			found = 1;
2938			break;
2939		}
2940	}
2941	if (!found) {
2942		pr_err("no overlay data for %s\n", overlay_name);
2943		return;
2944	}
2945
2946	info = &overlays[0];
2947
2948	if (info->expected_result != -9999) {
2949		pr_err("No dtb 'overlay_base' to attach\n");
2950		return;
2951	}
2952
2953	data_size = info->dtb_end - info->dtb_begin;
2954	if (!data_size) {
2955		pr_err("No dtb 'overlay_base' to attach\n");
2956		return;
2957	}
2958
2959	size = fdt_totalsize(info->dtb_begin);
2960	if (size != data_size) {
2961		pr_err("dtb 'overlay_base' header totalsize != actual size");
2962		return;
2963	}
2964
2965	new_fdt = dt_alloc_memory(size, roundup_pow_of_two(FDT_V17_SIZE));
2966	if (!new_fdt) {
2967		pr_err("alloc for dtb 'overlay_base' failed");
2968		return;
2969	}
2970
2971	memcpy(new_fdt, info->dtb_begin, size);
2972
2973	__unflatten_device_tree(new_fdt, NULL, &overlay_base_root,
2974				dt_alloc_memory, true);
2975}
2976
2977/*
2978 * The purpose of of_unittest_overlay_data_add is to add an
2979 * overlay in the normal fashion.  This is a test of the whole
2980 * picture, instead of testing individual elements.
2981 *
2982 * A secondary purpose is to be able to verify that the contents of
2983 * /proc/device-tree/ contains the updated structure and values from
2984 * the overlay.  That must be verified separately in user space.
2985 *
2986 * Return 0 on unexpected error.
2987 */
2988static int __init overlay_data_apply(const char *overlay_name, int *overlay_id)
2989{
2990	struct overlay_info *info;
2991	int found = 0;
2992	int ret;
2993	u32 size;
2994
2995	for (info = overlays; info && info->name; info++) {
2996		if (!strcmp(overlay_name, info->name)) {
2997			found = 1;
2998			break;
2999		}
3000	}
3001	if (!found) {
3002		pr_err("no overlay data for %s\n", overlay_name);
3003		return 0;
3004	}
3005
3006	size = info->dtb_end - info->dtb_begin;
3007	if (!size)
3008		pr_err("no overlay data for %s\n", overlay_name);
3009
3010	ret = of_overlay_fdt_apply(info->dtb_begin, size, &info->overlay_id);
3011	if (overlay_id)
3012		*overlay_id = info->overlay_id;
3013	if (ret < 0)
3014		goto out;
3015
3016	pr_debug("%s applied\n", overlay_name);
3017
3018out:
3019	if (ret != info->expected_result)
3020		pr_err("of_overlay_fdt_apply() expected %d, ret=%d, %s\n",
3021		       info->expected_result, ret, overlay_name);
3022
3023	return (ret == info->expected_result);
3024}
3025
3026/*
3027 * The purpose of of_unittest_overlay_high_level is to add an overlay
3028 * in the normal fashion.  This is a test of the whole picture,
3029 * instead of individual elements.
3030 *
3031 * The first part of the function is _not_ normal overlay usage; it is
3032 * finishing splicing the base overlay device tree into the live tree.
3033 */
3034static __init void of_unittest_overlay_high_level(void)
3035{
3036	struct device_node *last_sibling;
3037	struct device_node *np;
3038	struct device_node *of_symbols;
3039	struct device_node *overlay_base_symbols;
3040	struct device_node **pprev;
3041	struct property *prop;
3042	int ret;
3043
3044	if (!overlay_base_root) {
3045		unittest(0, "overlay_base_root not initialized\n");
3046		return;
3047	}
3048
3049	/*
3050	 * Could not fixup phandles in unittest_unflatten_overlay_base()
3051	 * because kmalloc() was not yet available.
3052	 */
3053	of_overlay_mutex_lock();
3054	of_resolve_phandles(overlay_base_root);
3055	of_overlay_mutex_unlock();
3056
3057
3058	/*
3059	 * do not allow overlay_base to duplicate any node already in
3060	 * tree, this greatly simplifies the code
3061	 */
3062
3063	/*
3064	 * remove overlay_base_root node "__local_fixups", after
3065	 * being used by of_resolve_phandles()
3066	 */
3067	pprev = &overlay_base_root->child;
3068	for (np = overlay_base_root->child; np; np = np->sibling) {
3069		if (of_node_name_eq(np, "__local_fixups__")) {
3070			*pprev = np->sibling;
3071			break;
3072		}
3073		pprev = &np->sibling;
3074	}
3075
3076	/* remove overlay_base_root node "__symbols__" if in live tree */
3077	of_symbols = of_get_child_by_name(of_root, "__symbols__");
3078	if (of_symbols) {
3079		/* will have to graft properties from node into live tree */
3080		pprev = &overlay_base_root->child;
3081		for (np = overlay_base_root->child; np; np = np->sibling) {
3082			if (of_node_name_eq(np, "__symbols__")) {
3083				overlay_base_symbols = np;
3084				*pprev = np->sibling;
3085				break;
3086			}
3087			pprev = &np->sibling;
3088		}
3089	}
3090
3091	for_each_child_of_node(overlay_base_root, np) {
3092		struct device_node *base_child;
3093		for_each_child_of_node(of_root, base_child) {
3094			if (!strcmp(np->full_name, base_child->full_name)) {
3095				unittest(0, "illegal node name in overlay_base %pOFn",
3096					 np);
3097				return;
3098			}
3099		}
3100	}
3101
3102	/*
3103	 * overlay 'overlay_base' is not allowed to have root
3104	 * properties, so only need to splice nodes into main device tree.
3105	 *
3106	 * root node of *overlay_base_root will not be freed, it is lost
3107	 * memory.
3108	 */
3109
3110	for (np = overlay_base_root->child; np; np = np->sibling)
3111		np->parent = of_root;
3112
3113	mutex_lock(&of_mutex);
3114
3115	for (last_sibling = np = of_root->child; np; np = np->sibling)
3116		last_sibling = np;
3117
3118	if (last_sibling)
3119		last_sibling->sibling = overlay_base_root->child;
3120	else
3121		of_root->child = overlay_base_root->child;
3122
3123	for_each_of_allnodes_from(overlay_base_root, np)
3124		__of_attach_node_sysfs(np);
3125
3126	if (of_symbols) {
3127		struct property *new_prop;
3128		for_each_property_of_node(overlay_base_symbols, prop) {
3129
3130			new_prop = __of_prop_dup(prop, GFP_KERNEL);
3131			if (!new_prop) {
3132				unittest(0, "__of_prop_dup() of '%s' from overlay_base node __symbols__",
3133					 prop->name);
3134				goto err_unlock;
3135			}
3136			if (__of_add_property(of_symbols, new_prop)) {
3137				kfree(new_prop->name);
3138				kfree(new_prop->value);
3139				kfree(new_prop);
3140				/* "name" auto-generated by unflatten */
3141				if (!strcmp(prop->name, "name"))
3142					continue;
3143				unittest(0, "duplicate property '%s' in overlay_base node __symbols__",
3144					 prop->name);
3145				goto err_unlock;
3146			}
3147			if (__of_add_property_sysfs(of_symbols, new_prop)) {
3148				unittest(0, "unable to add property '%s' in overlay_base node __symbols__ to sysfs",
3149					 prop->name);
3150				goto err_unlock;
3151			}
3152		}
3153	}
3154
3155	mutex_unlock(&of_mutex);
3156
3157
3158	/* now do the normal overlay usage test */
3159
3160	EXPECT_BEGIN(KERN_ERR,
3161		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/substation@100/status");
3162	EXPECT_BEGIN(KERN_ERR,
3163		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/status");
3164	EXPECT_BEGIN(KERN_ERR,
3165		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@30/incline-up");
3166	EXPECT_BEGIN(KERN_ERR,
3167		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@40/incline-up");
3168	EXPECT_BEGIN(KERN_ERR,
3169		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/status");
3170	EXPECT_BEGIN(KERN_ERR,
3171		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/color");
3172	EXPECT_BEGIN(KERN_ERR,
3173		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/rate");
3174	EXPECT_BEGIN(KERN_ERR,
3175		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/hvac_2");
3176	EXPECT_BEGIN(KERN_ERR,
3177		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200");
3178	EXPECT_BEGIN(KERN_ERR,
3179		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_left");
3180	EXPECT_BEGIN(KERN_ERR,
3181		     "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_right");
3182
3183	ret = overlay_data_apply("overlay", NULL);
3184
3185	EXPECT_END(KERN_ERR,
3186		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_right");
3187	EXPECT_END(KERN_ERR,
3188		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_left");
3189	EXPECT_END(KERN_ERR,
3190		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200");
3191	EXPECT_END(KERN_ERR,
3192		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/hvac_2");
3193	EXPECT_END(KERN_ERR,
3194		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/rate");
3195	EXPECT_END(KERN_ERR,
3196		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/color");
3197	EXPECT_END(KERN_ERR,
3198		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/status");
3199	EXPECT_END(KERN_ERR,
3200		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@40/incline-up");
3201	EXPECT_END(KERN_ERR,
3202		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@30/incline-up");
3203	EXPECT_END(KERN_ERR,
3204		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/status");
3205	EXPECT_END(KERN_ERR,
3206		   "OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/substation@100/status");
3207
3208	unittest(ret, "Adding overlay 'overlay' failed\n");
3209
3210	EXPECT_BEGIN(KERN_ERR,
3211		     "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/controller");
3212	EXPECT_BEGIN(KERN_ERR,
3213		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/controller/name");
3214
3215	unittest(overlay_data_apply("overlay_bad_add_dup_node", NULL),
3216		 "Adding overlay 'overlay_bad_add_dup_node' failed\n");
3217
3218	EXPECT_END(KERN_ERR,
3219		   "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/controller/name");
3220	EXPECT_END(KERN_ERR,
3221		   "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/controller");
3222
3223	EXPECT_BEGIN(KERN_ERR,
3224		     "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/electric");
3225	EXPECT_BEGIN(KERN_ERR,
3226		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/rpm_avail");
3227	EXPECT_BEGIN(KERN_ERR,
3228		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/name");
3229
3230	unittest(overlay_data_apply("overlay_bad_add_dup_prop", NULL),
3231		 "Adding overlay 'overlay_bad_add_dup_prop' failed\n");
3232
3233	EXPECT_END(KERN_ERR,
3234		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/name");
3235	EXPECT_END(KERN_ERR,
3236		     "OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/rpm_avail");
3237	EXPECT_END(KERN_ERR,
3238		     "OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/electric");
3239
3240	unittest(overlay_data_apply("overlay_bad_phandle", NULL),
3241		 "Adding overlay 'overlay_bad_phandle' failed\n");
3242
3243	unittest(overlay_data_apply("overlay_bad_symbol", NULL),
3244		 "Adding overlay 'overlay_bad_symbol' failed\n");
3245
3246	return;
3247
3248err_unlock:
3249	mutex_unlock(&of_mutex);
3250}
3251
3252#else
3253
3254static inline __init void of_unittest_overlay_high_level(void) {}
3255
3256#endif
3257
3258static int __init of_unittest(void)
3259{
3260	struct device_node *np;
3261	int res;
3262
3263	pr_info("start of unittest - you will see error messages\n");
3264
3265	/* adding data for unittest */
3266
3267	if (IS_ENABLED(CONFIG_UML))
3268		unittest_unflatten_overlay_base();
3269
3270	res = unittest_data_add();
3271	if (res)
3272		return res;
3273	if (!of_aliases)
3274		of_aliases = of_find_node_by_path("/aliases");
3275
3276	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
3277	if (!np) {
3278		pr_info("No testcase data in device tree; not running tests\n");
3279		return 0;
3280	}
3281	of_node_put(np);
3282
3283	of_unittest_check_tree_linkage();
3284	of_unittest_check_phandles();
3285	of_unittest_find_node_by_name();
3286	of_unittest_dynamic();
3287	of_unittest_parse_phandle_with_args();
3288	of_unittest_parse_phandle_with_args_map();
3289	of_unittest_printf();
3290	of_unittest_property_string();
3291	of_unittest_property_copy();
3292	of_unittest_changeset();
3293	of_unittest_parse_interrupts();
3294	of_unittest_parse_interrupts_extended();
3295	of_unittest_dma_get_max_cpu_address();
3296	of_unittest_parse_dma_ranges();
3297	of_unittest_pci_dma_ranges();
3298	of_unittest_match_node();
3299	of_unittest_platform_populate();
3300	of_unittest_overlay();
3301
3302	/* Double check linkage after removing testcase data */
3303	of_unittest_check_tree_linkage();
3304
3305	of_unittest_overlay_high_level();
3306
3307	pr_info("end of unittest - %i passed, %i failed\n",
3308		unittest_results.passed, unittest_results.failed);
3309
3310	return 0;
3311}
3312late_initcall(of_unittest);