unittest.c 66.0 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
G
Grant Likely 已提交
2 3 4 5
/*
 * Self tests for device tree subsystem
 */

6
#define pr_fmt(fmt) "### dt-test ### " fmt
G
Grant Likely 已提交
7

8
#include <linux/bootmem.h>
G
Grant Likely 已提交
9 10 11
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/errno.h>
12
#include <linux/hashtable.h>
13
#include <linux/libfdt.h>
G
Grant Likely 已提交
14
#include <linux/of.h>
15
#include <linux/of_fdt.h>
16
#include <linux/of_irq.h>
17
#include <linux/of_platform.h>
G
Grant Likely 已提交
18 19 20 21
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/device.h>
22
#include <linux/platform_device.h>
G
Grant Likely 已提交
23

24 25 26
#include <linux/i2c.h>
#include <linux/i2c-mux.h>

27 28
#include <linux/bitops.h>

29 30
#include "of_private.h"

31
static struct unittest_results {
32 33
	int passed;
	int failed;
34
} unittest_results;
35

36
#define unittest(result, fmt, ...) ({ \
37 38
	bool failed = !(result); \
	if (failed) { \
39
		unittest_results.failed++; \
40
		pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
41
	} else { \
42
		unittest_results.passed++; \
43
		pr_debug("pass %s():%i\n", __func__, __LINE__); \
44
	} \
45 46
	failed; \
})
G
Grant Likely 已提交
47

48
static void __init of_unittest_find_node_by_name(void)
49 50
{
	struct device_node *np;
51
	const char *options, *name;
52 53

	np = of_find_node_by_path("/testcase-data");
54 55
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	unittest(np && !strcmp("/testcase-data", name),
56 57
		"find /testcase-data failed\n");
	of_node_put(np);
58
	kfree(name);
59 60 61

	/* Test if trailing '/' works */
	np = of_find_node_by_path("/testcase-data/");
62
	unittest(!np, "trailing '/' on /testcase-data/ should fail\n");
63 64

	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
65 66
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
67 68
		"find /testcase-data/phandle-tests/consumer-a failed\n");
	of_node_put(np);
69
	kfree(name);
70 71

	np = of_find_node_by_path("testcase-alias");
72 73
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	unittest(np && !strcmp("/testcase-data", name),
74 75
		"find testcase-alias failed\n");
	of_node_put(np);
76
	kfree(name);
77 78 79

	/* Test if trailing '/' works on aliases */
	np = of_find_node_by_path("testcase-alias/");
80
	unittest(!np, "trailing '/' on testcase-alias/ should fail\n");
81 82

	np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
83 84
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
85 86
		"find testcase-alias/phandle-tests/consumer-a failed\n");
	of_node_put(np);
87
	kfree(name);
88 89

	np = of_find_node_by_path("/testcase-data/missing-path");
90
	unittest(!np, "non-existent path returned node %pOF\n", np);
91 92 93
	of_node_put(np);

	np = of_find_node_by_path("missing-alias");
94
	unittest(!np, "non-existent alias returned node %pOF\n", np);
95 96 97
	of_node_put(np);

	np = of_find_node_by_path("testcase-alias/missing-path");
98
	unittest(!np, "non-existent alias with relative path returned node %pOF\n", np);
99
	of_node_put(np);
100 101

	np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
102
	unittest(np && !strcmp("testoption", options),
103 104 105
		 "option path test failed\n");
	of_node_put(np);

106
	np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
107
	unittest(np && !strcmp("test/option", options),
108 109 110
		 "option path test, subcase #1 failed\n");
	of_node_put(np);

111
	np = of_find_node_opts_by_path("/testcase-data/testcase-device1:test/option", &options);
112
	unittest(np && !strcmp("test/option", options),
113 114 115
		 "option path test, subcase #2 failed\n");
	of_node_put(np);

116
	np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
117
	unittest(np, "NULL option path test failed\n");
118 119 120 121
	of_node_put(np);

	np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
				       &options);
122
	unittest(np && !strcmp("testaliasoption", options),
123 124 125
		 "option alias path test failed\n");
	of_node_put(np);

126 127
	np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
				       &options);
128
	unittest(np && !strcmp("test/alias/option", options),
129 130 131
		 "option alias path test, subcase #1 failed\n");
	of_node_put(np);

132
	np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
133
	unittest(np, "NULL option alias path test failed\n");
134 135 136 137
	of_node_put(np);

	options = "testoption";
	np = of_find_node_opts_by_path("testcase-alias", &options);
138
	unittest(np && !options, "option clearing test failed\n");
139 140 141 142
	of_node_put(np);

	options = "testoption";
	np = of_find_node_opts_by_path("/", &options);
143
	unittest(np && !options, "option clearing root node test failed\n");
144
	of_node_put(np);
145 146
}

147
static void __init of_unittest_dynamic(void)
148 149 150 151 152 153 154 155 156 157 158 159 160
{
	struct device_node *np;
	struct property *prop;

	np = of_find_node_by_path("/testcase-data");
	if (!np) {
		pr_err("missing testcase data\n");
		return;
	}

	/* Array of 4 properties for the purpose of testing */
	prop = kzalloc(sizeof(*prop) * 4, GFP_KERNEL);
	if (!prop) {
161
		unittest(0, "kzalloc() failed\n");
162 163 164 165 166 167
		return;
	}

	/* Add a new property - should pass*/
	prop->name = "new-property";
	prop->value = "new-property-data";
168
	prop->length = strlen(prop->value) + 1;
169
	unittest(of_add_property(np, prop) == 0, "Adding a new property failed\n");
170 171 172 173 174

	/* Try to add an existing property - should fail */
	prop++;
	prop->name = "new-property";
	prop->value = "new-property-data-should-fail";
175
	prop->length = strlen(prop->value) + 1;
176
	unittest(of_add_property(np, prop) != 0,
177 178 179 180
		 "Adding an existing property should have failed\n");

	/* Try to modify an existing property - should pass */
	prop->value = "modify-property-data-should-pass";
181
	prop->length = strlen(prop->value) + 1;
182
	unittest(of_update_property(np, prop) == 0,
183 184 185 186 187 188
		 "Updating an existing property should have passed\n");

	/* Try to modify non-existent property - should pass*/
	prop++;
	prop->name = "modify-property";
	prop->value = "modify-missing-property-data-should-pass";
189
	prop->length = strlen(prop->value) + 1;
190
	unittest(of_update_property(np, prop) == 0,
191 192 193
		 "Updating a missing property should have passed\n");

	/* Remove property - should pass */
194
	unittest(of_remove_property(np, prop) == 0,
195 196 197 198 199 200 201
		 "Removing a property should have passed\n");

	/* Adding very large property - should pass */
	prop++;
	prop->name = "large-property-PAGE_SIZEx8";
	prop->length = PAGE_SIZE * 8;
	prop->value = kzalloc(prop->length, GFP_KERNEL);
202
	unittest(prop->value != NULL, "Unable to allocate large buffer\n");
203
	if (prop->value)
204
		unittest(of_add_property(np, prop) == 0,
205 206 207
			 "Adding a large property should have passed\n");
}

208
static int __init of_unittest_check_node_linkage(struct device_node *np)
209
{
G
Grant Likely 已提交
210
	struct device_node *child;
211 212 213 214 215 216
	int count = 0, rc;

	for_each_child_of_node(np, child) {
		if (child->parent != np) {
			pr_err("Child node %s links to wrong parent %s\n",
				 child->name, np->name);
217 218
			rc = -EINVAL;
			goto put_child;
219 220
		}

221
		rc = of_unittest_check_node_linkage(child);
222
		if (rc < 0)
223
			goto put_child;
224 225 226 227
		count += rc;
	}

	return count + 1;
228 229 230
put_child:
	of_node_put(child);
	return rc;
231 232
}

233
static void __init of_unittest_check_tree_linkage(void)
234 235 236 237
{
	struct device_node *np;
	int allnode_count = 0, child_count;

G
Grant Likely 已提交
238
	if (!of_root)
239 240 241 242
		return;

	for_each_of_allnodes(np)
		allnode_count++;
243
	child_count = of_unittest_check_node_linkage(of_root);
244

245
	unittest(child_count > 0, "Device node data structure is corrupted\n");
246
	unittest(child_count == allnode_count,
F
Frank Rowand 已提交
247 248
		 "allnodes list size (%i) doesn't match sibling lists size (%i)\n",
		 allnode_count, child_count);
249 250 251
	pr_debug("allnodes list size (%i); sibling lists size (%i)\n", allnode_count, child_count);
}

252 253 254
static void __init of_unittest_printf_one(struct device_node *np, const char *fmt,
					  const char *expected)
{
255 256
	unsigned char *buf;
	int buf_size;
257 258
	int size, i;

259 260 261 262 263
	buf_size = strlen(expected) + 10;
	buf = kmalloc(buf_size, GFP_KERNEL);
	if (!buf)
		return;

264
	/* Baseline; check conversion with a large size limit */
265 266
	memset(buf, 0xff, buf_size);
	size = snprintf(buf, buf_size - 2, fmt, np);
267 268 269 270 271 272 273 274 275 276

	/* use strcmp() instead of strncmp() here to be absolutely sure strings match */
	unittest((strcmp(buf, expected) == 0) && (buf[size+1] == 0xff),
		"sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
		fmt, expected, buf);

	/* Make sure length limits work */
	size++;
	for (i = 0; i < 2; i++, size--) {
		/* Clear the buffer, and make sure it works correctly still */
277
		memset(buf, 0xff, buf_size);
278 279 280 281 282
		snprintf(buf, size+1, fmt, np);
		unittest(strncmp(buf, expected, size) == 0 && (buf[size+1] == 0xff),
			"snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
			size, fmt, expected, buf);
	}
283
	kfree(buf);
284 285 286 287 288 289 290 291 292 293 294 295 296 297
}

static void __init of_unittest_printf(void)
{
	struct device_node *np;
	const char *full_name = "/testcase-data/platform-tests/test-device@1/dev@100";
	char phandle_str[16] = "";

	np = of_find_node_by_path(full_name);
	if (!np) {
		unittest(np, "testcase data missing\n");
		return;
	}

298
	num_to_str(phandle_str, sizeof(phandle_str), np->phandle, 0);
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315

	of_unittest_printf_one(np, "%pOF",  full_name);
	of_unittest_printf_one(np, "%pOFf", full_name);
	of_unittest_printf_one(np, "%pOFp", phandle_str);
	of_unittest_printf_one(np, "%pOFP", "dev@100");
	of_unittest_printf_one(np, "ABC %pOFP ABC", "ABC dev@100 ABC");
	of_unittest_printf_one(np, "%10pOFP", "   dev@100");
	of_unittest_printf_one(np, "%-10pOFP", "dev@100   ");
	of_unittest_printf_one(of_root, "%pOFP", "/");
	of_unittest_printf_one(np, "%pOFF", "----");
	of_unittest_printf_one(np, "%pOFPF", "dev@100:----");
	of_unittest_printf_one(np, "%pOFPFPc", "dev@100:----:dev@100:test-sub-device");
	of_unittest_printf_one(np, "%pOFc", "test-sub-device");
	of_unittest_printf_one(np, "%pOFC",
			"\"test-sub-device\",\"test-compat2\",\"test-compat3\"");
}

316 317 318 319 320
struct node_hash {
	struct hlist_node node;
	struct device_node *np;
};

321
static DEFINE_HASHTABLE(phandle_ht, 8);
322
static void __init of_unittest_check_phandles(void)
323 324 325 326 327 328 329 330 331 332
{
	struct device_node *np;
	struct node_hash *nh;
	struct hlist_node *tmp;
	int i, dup_count = 0, phandle_count = 0;

	for_each_of_allnodes(np) {
		if (!np->phandle)
			continue;

333
		hash_for_each_possible(phandle_ht, nh, node, np->phandle) {
334
			if (nh->np->phandle == np->phandle) {
335 336
				pr_info("Duplicate phandle! %i used by %pOF and %pOF\n",
					np->phandle, nh->np, np);
337 338 339 340 341 342 343 344 345 346
				dup_count++;
				break;
			}
		}

		nh = kzalloc(sizeof(*nh), GFP_KERNEL);
		if (WARN_ON(!nh))
			return;

		nh->np = np;
347
		hash_add(phandle_ht, &nh->node, np->phandle);
348 349
		phandle_count++;
	}
350
	unittest(dup_count == 0, "Found %i duplicates in %i phandles\n",
351 352 353
		 dup_count, phandle_count);

	/* Clean up */
354
	hash_for_each_safe(phandle_ht, i, tmp, nh, node) {
355 356 357 358 359
		hash_del(&nh->node);
		kfree(nh);
	}
}

360
static void __init of_unittest_parse_phandle_with_args(void)
G
Grant Likely 已提交
361 362 363
{
	struct device_node *np;
	struct of_phandle_args args;
364
	int i, rc;
G
Grant Likely 已提交
365 366 367 368 369 370 371

	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
	if (!np) {
		pr_err("missing testcase data\n");
		return;
	}

372
	rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
373
	unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
374

375
	for (i = 0; i < 8; i++) {
G
Grant Likely 已提交
376
		bool passed = true;
377

G
Grant Likely 已提交
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
		rc = of_parse_phandle_with_args(np, "phandle-list",
						"#phandle-cells", i, &args);

		/* Test the values from tests-phandle.dtsi */
		switch (i) {
		case 0:
			passed &= !rc;
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == (i + 1));
			break;
		case 1:
			passed &= !rc;
			passed &= (args.args_count == 2);
			passed &= (args.args[0] == (i + 1));
			passed &= (args.args[1] == 0);
			break;
		case 2:
			passed &= (rc == -ENOENT);
			break;
		case 3:
			passed &= !rc;
			passed &= (args.args_count == 3);
			passed &= (args.args[0] == (i + 1));
			passed &= (args.args[1] == 4);
			passed &= (args.args[2] == 3);
			break;
		case 4:
			passed &= !rc;
			passed &= (args.args_count == 2);
			passed &= (args.args[0] == (i + 1));
			passed &= (args.args[1] == 100);
			break;
		case 5:
			passed &= !rc;
			passed &= (args.args_count == 0);
			break;
		case 6:
			passed &= !rc;
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == (i + 1));
			break;
		case 7:
420
			passed &= (rc == -ENOENT);
G
Grant Likely 已提交
421 422 423 424 425
			break;
		default:
			passed = false;
		}

426 427
		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
			 i, args.np, rc);
G
Grant Likely 已提交
428 429 430 431 432
	}

	/* Check for missing list property */
	rc = of_parse_phandle_with_args(np, "phandle-list-missing",
					"#phandle-cells", 0, &args);
433
	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
434 435
	rc = of_count_phandle_with_args(np, "phandle-list-missing",
					"#phandle-cells");
436
	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
G
Grant Likely 已提交
437 438 439 440

	/* Check for missing cells property */
	rc = of_parse_phandle_with_args(np, "phandle-list",
					"#phandle-cells-missing", 0, &args);
441
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
442 443
	rc = of_count_phandle_with_args(np, "phandle-list",
					"#phandle-cells-missing");
444
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
G
Grant Likely 已提交
445 446 447 448

	/* Check for bad phandle in list */
	rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle",
					"#phandle-cells", 0, &args);
449
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
450 451
	rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle",
					"#phandle-cells");
452
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
G
Grant Likely 已提交
453 454 455 456

	/* Check for incorrectly formed argument list */
	rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
					"#phandle-cells", 1, &args);
457
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
458 459
	rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
					"#phandle-cells");
460
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
G
Grant Likely 已提交
461 462
}

463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
static void __init of_unittest_parse_phandle_with_args_map(void)
{
	struct device_node *np, *p0, *p1, *p2, *p3;
	struct of_phandle_args args;
	int i, rc;

	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-b");
	if (!np) {
		pr_err("missing testcase data\n");
		return;
	}

	p0 = of_find_node_by_path("/testcase-data/phandle-tests/provider0");
	if (!p0) {
		pr_err("missing testcase data\n");
		return;
	}

	p1 = of_find_node_by_path("/testcase-data/phandle-tests/provider1");
	if (!p1) {
		pr_err("missing testcase data\n");
		return;
	}

	p2 = of_find_node_by_path("/testcase-data/phandle-tests/provider2");
	if (!p2) {
		pr_err("missing testcase data\n");
		return;
	}

	p3 = of_find_node_by_path("/testcase-data/phandle-tests/provider3");
	if (!p3) {
		pr_err("missing testcase data\n");
		return;
	}

	rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
	unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);

	for (i = 0; i < 8; i++) {
		bool passed = true;

		rc = of_parse_phandle_with_args_map(np, "phandle-list",
						    "phandle", i, &args);

		/* Test the values from tests-phandle.dtsi */
		switch (i) {
		case 0:
			passed &= !rc;
			passed &= (args.np == p1);
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == 1);
			break;
		case 1:
			passed &= !rc;
			passed &= (args.np == p3);
			passed &= (args.args_count == 3);
			passed &= (args.args[0] == 2);
			passed &= (args.args[1] == 5);
			passed &= (args.args[2] == 3);
			break;
		case 2:
			passed &= (rc == -ENOENT);
			break;
		case 3:
			passed &= !rc;
			passed &= (args.np == p0);
			passed &= (args.args_count == 0);
			break;
		case 4:
			passed &= !rc;
			passed &= (args.np == p1);
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == 3);
			break;
		case 5:
			passed &= !rc;
			passed &= (args.np == p0);
			passed &= (args.args_count == 0);
			break;
		case 6:
			passed &= !rc;
			passed &= (args.np == p2);
			passed &= (args.args_count == 2);
			passed &= (args.args[0] == 15);
			passed &= (args.args[1] == 0x20);
			break;
		case 7:
			passed &= (rc == -ENOENT);
			break;
		default:
			passed = false;
		}

		unittest(passed, "index %i - data error on node %s rc=%i\n",
			 i, args.np->full_name, rc);
	}

	/* Check for missing list property */
	rc = of_parse_phandle_with_args_map(np, "phandle-list-missing",
					    "phandle", 0, &args);
	unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);

	/* Check for missing cells,map,mask property */
	rc = of_parse_phandle_with_args_map(np, "phandle-list",
					    "phandle-missing", 0, &args);
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);

	/* Check for bad phandle in list */
	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-phandle",
					    "phandle", 0, &args);
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);

	/* Check for incorrectly formed argument list */
	rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-args",
					    "phandle", 1, &args);
	unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
}

582
static void __init of_unittest_property_string(void)
583
{
584
	const char *strings[4];
585 586 587 588 589 590 591 592 593 594
	struct device_node *np;
	int rc;

	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
	if (!np) {
		pr_err("No testcase data in device tree\n");
		return;
	}

	rc = of_property_match_string(np, "phandle-list-names", "first");
595
	unittest(rc == 0, "first expected:0 got:%i\n", rc);
596
	rc = of_property_match_string(np, "phandle-list-names", "second");
597
	unittest(rc == 1, "second expected:1 got:%i\n", rc);
598
	rc = of_property_match_string(np, "phandle-list-names", "third");
599
	unittest(rc == 2, "third expected:2 got:%i\n", rc);
600
	rc = of_property_match_string(np, "phandle-list-names", "fourth");
601
	unittest(rc == -ENODATA, "unmatched string; rc=%i\n", rc);
602
	rc = of_property_match_string(np, "missing-property", "blah");
603
	unittest(rc == -EINVAL, "missing property; rc=%i\n", rc);
604
	rc = of_property_match_string(np, "empty-property", "blah");
605
	unittest(rc == -ENODATA, "empty property; rc=%i\n", rc);
606
	rc = of_property_match_string(np, "unterminated-string", "blah");
607
	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
608 609 610

	/* of_property_count_strings() tests */
	rc = of_property_count_strings(np, "string-property");
611
	unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
612
	rc = of_property_count_strings(np, "phandle-list-names");
613
	unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
614
	rc = of_property_count_strings(np, "unterminated-string");
615
	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
616
	rc = of_property_count_strings(np, "unterminated-string-list");
617
	unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
618 619 620

	/* of_property_read_string_index() tests */
	rc = of_property_read_string_index(np, "string-property", 0, strings);
621
	unittest(rc == 0 && !strcmp(strings[0], "foobar"), "of_property_read_string_index() failure; rc=%i\n", rc);
622 623
	strings[0] = NULL;
	rc = of_property_read_string_index(np, "string-property", 1, strings);
624
	unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
625
	rc = of_property_read_string_index(np, "phandle-list-names", 0, strings);
626
	unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
627
	rc = of_property_read_string_index(np, "phandle-list-names", 1, strings);
628
	unittest(rc == 0 && !strcmp(strings[0], "second"), "of_property_read_string_index() failure; rc=%i\n", rc);
629
	rc = of_property_read_string_index(np, "phandle-list-names", 2, strings);
630
	unittest(rc == 0 && !strcmp(strings[0], "third"), "of_property_read_string_index() failure; rc=%i\n", rc);
631 632
	strings[0] = NULL;
	rc = of_property_read_string_index(np, "phandle-list-names", 3, strings);
633
	unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
634 635
	strings[0] = NULL;
	rc = of_property_read_string_index(np, "unterminated-string", 0, strings);
636
	unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
637
	rc = of_property_read_string_index(np, "unterminated-string-list", 0, strings);
638
	unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
639 640
	strings[0] = NULL;
	rc = of_property_read_string_index(np, "unterminated-string-list", 2, strings); /* should fail */
641
	unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
642 643 644 645
	strings[1] = NULL;

	/* of_property_read_string_array() tests */
	rc = of_property_read_string_array(np, "string-property", strings, 4);
646
	unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
647
	rc = of_property_read_string_array(np, "phandle-list-names", strings, 4);
648
	unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
649
	rc = of_property_read_string_array(np, "unterminated-string", strings, 4);
650
	unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
651 652
	/* -- An incorrectly formed string should cause a failure */
	rc = of_property_read_string_array(np, "unterminated-string-list", strings, 4);
653
	unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
654 655 656
	/* -- parsing the correctly formed strings should still work: */
	strings[2] = NULL;
	rc = of_property_read_string_array(np, "unterminated-string-list", strings, 2);
657
	unittest(rc == 2 && strings[2] == NULL, "of_property_read_string_array() failure; rc=%i\n", rc);
658 659
	strings[1] = NULL;
	rc = of_property_read_string_array(np, "phandle-list-names", strings, 1);
660
	unittest(rc == 1 && strings[1] == NULL, "Overwrote end of string array; rc=%i, str='%s'\n", rc, strings[1]);
661 662
}

663 664 665 666
#define propcmp(p1, p2) (((p1)->length == (p2)->length) && \
			(p1)->value && (p2)->value && \
			!memcmp((p1)->value, (p2)->value, (p1)->length) && \
			!strcmp((p1)->name, (p2)->name))
667
static void __init of_unittest_property_copy(void)
668 669 670 671 672 673 674
{
#ifdef CONFIG_OF_DYNAMIC
	struct property p1 = { .name = "p1", .length = 0, .value = "" };
	struct property p2 = { .name = "p2", .length = 5, .value = "abcd" };
	struct property *new;

	new = __of_prop_dup(&p1, GFP_KERNEL);
675
	unittest(new && propcmp(&p1, new), "empty property didn't copy correctly\n");
676 677 678 679 680
	kfree(new->value);
	kfree(new->name);
	kfree(new);

	new = __of_prop_dup(&p2, GFP_KERNEL);
681
	unittest(new && propcmp(&p2, new), "non-empty property didn't copy correctly\n");
682 683 684 685 686 687
	kfree(new->value);
	kfree(new->name);
	kfree(new);
#endif
}

688
static void __init of_unittest_changeset(void)
689 690
{
#ifdef CONFIG_OF_DYNAMIC
691 692 693 694
	struct property *ppadd, padd = { .name = "prop-add", .length = 1, .value = "" };
	struct property *ppname_n1,  pname_n1  = { .name = "name", .length = 3, .value = "n1"  };
	struct property *ppname_n2,  pname_n2  = { .name = "name", .length = 3, .value = "n2"  };
	struct property *ppname_n21, pname_n21 = { .name = "name", .length = 3, .value = "n21" };
695 696
	struct property *ppupdate, pupdate = { .name = "prop-update", .length = 5, .value = "abcd" };
	struct property *ppremove;
697
	struct device_node *n1, *n2, *n21, *nchangeset, *nremove, *parent, *np;
698 699
	struct of_changeset chgset;

700
	n1 = __of_node_dup(NULL, "n1");
701
	unittest(n1, "testcase setup failure\n");
702

703
	n2 = __of_node_dup(NULL, "n2");
704
	unittest(n2, "testcase setup failure\n");
705

706
	n21 = __of_node_dup(NULL, "n21");
707
	unittest(n21, "testcase setup failure %p\n", n21);
708 709 710

	nchangeset = of_find_node_by_path("/testcase-data/changeset");
	nremove = of_get_child_by_name(nchangeset, "node-remove");
711
	unittest(nremove, "testcase setup failure\n");
712

713
	ppadd = __of_prop_dup(&padd, GFP_KERNEL);
714
	unittest(ppadd, "testcase setup failure\n");
715 716 717 718 719 720 721 722 723 724

	ppname_n1  = __of_prop_dup(&pname_n1, GFP_KERNEL);
	unittest(ppname_n1, "testcase setup failure\n");

	ppname_n2  = __of_prop_dup(&pname_n2, GFP_KERNEL);
	unittest(ppname_n2, "testcase setup failure\n");

	ppname_n21 = __of_prop_dup(&pname_n21, GFP_KERNEL);
	unittest(ppname_n21, "testcase setup failure\n");

725
	ppupdate = __of_prop_dup(&pupdate, GFP_KERNEL);
726
	unittest(ppupdate, "testcase setup failure\n");
727 728

	parent = nchangeset;
729 730 731
	n1->parent = parent;
	n2->parent = parent;
	n21->parent = n2;
732

733
	ppremove = of_find_property(parent, "prop-remove", NULL);
734
	unittest(ppremove, "failed to find removal prop");
735 736

	of_changeset_init(&chgset);
737

738
	unittest(!of_changeset_attach_node(&chgset, n1), "fail attach n1\n");
739 740
	unittest(!of_changeset_add_property(&chgset, n1, ppname_n1), "fail add prop name\n");

741
	unittest(!of_changeset_attach_node(&chgset, n2), "fail attach n2\n");
742 743
	unittest(!of_changeset_add_property(&chgset, n2, ppname_n2), "fail add prop name\n");

744
	unittest(!of_changeset_detach_node(&chgset, nremove), "fail remove node\n");
745 746
	unittest(!of_changeset_add_property(&chgset, n21, ppname_n21), "fail add prop name\n");

747
	unittest(!of_changeset_attach_node(&chgset, n21), "fail attach n21\n");
748 749

	unittest(!of_changeset_add_property(&chgset, parent, ppadd), "fail add prop prop-add\n");
750 751
	unittest(!of_changeset_update_property(&chgset, parent, ppupdate), "fail update prop\n");
	unittest(!of_changeset_remove_property(&chgset, parent, ppremove), "fail remove prop\n");
752

753
	unittest(!of_changeset_apply(&chgset), "apply failed\n");
754

755 756
	of_node_put(nchangeset);

757
	/* Make sure node names are constructed correctly */
758
	unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n21")),
759
		 "'%pOF' not added\n", n21);
760
	of_node_put(np);
761

762
	unittest(!of_changeset_revert(&chgset), "revert failed\n");
763 764 765 766 767

	of_changeset_destroy(&chgset);
#endif
}

768
static void __init of_unittest_parse_interrupts(void)
769 770 771 772 773 774 775 776 777 778 779 780 781
{
	struct device_node *np;
	struct of_phandle_args args;
	int i, rc;

	np = of_find_node_by_path("/testcase-data/interrupts/interrupts0");
	if (!np) {
		pr_err("missing testcase data\n");
		return;
	}

	for (i = 0; i < 4; i++) {
		bool passed = true;
782

783 784 785 786 787 788 789
		args.args_count = 0;
		rc = of_irq_parse_one(np, i, &args);

		passed &= !rc;
		passed &= (args.args_count == 1);
		passed &= (args.args[0] == (i + 1));

790 791
		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
			 i, args.np, rc);
792 793 794 795 796 797 798 799 800 801 802
	}
	of_node_put(np);

	np = of_find_node_by_path("/testcase-data/interrupts/interrupts1");
	if (!np) {
		pr_err("missing testcase data\n");
		return;
	}

	for (i = 0; i < 4; i++) {
		bool passed = true;
803

804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
		args.args_count = 0;
		rc = of_irq_parse_one(np, i, &args);

		/* Test the values from tests-phandle.dtsi */
		switch (i) {
		case 0:
			passed &= !rc;
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == 9);
			break;
		case 1:
			passed &= !rc;
			passed &= (args.args_count == 3);
			passed &= (args.args[0] == 10);
			passed &= (args.args[1] == 11);
			passed &= (args.args[2] == 12);
			break;
		case 2:
			passed &= !rc;
			passed &= (args.args_count == 2);
			passed &= (args.args[0] == 13);
			passed &= (args.args[1] == 14);
			break;
		case 3:
			passed &= !rc;
			passed &= (args.args_count == 2);
			passed &= (args.args[0] == 15);
			passed &= (args.args[1] == 16);
			break;
		default:
			passed = false;
		}
836 837
		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
			 i, args.np, rc);
838 839 840 841
	}
	of_node_put(np);
}

842
static void __init of_unittest_parse_interrupts_extended(void)
843 844 845 846 847 848 849 850 851 852 853 854 855
{
	struct device_node *np;
	struct of_phandle_args args;
	int i, rc;

	np = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0");
	if (!np) {
		pr_err("missing testcase data\n");
		return;
	}

	for (i = 0; i < 7; i++) {
		bool passed = true;
856

857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905
		rc = of_irq_parse_one(np, i, &args);

		/* Test the values from tests-phandle.dtsi */
		switch (i) {
		case 0:
			passed &= !rc;
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == 1);
			break;
		case 1:
			passed &= !rc;
			passed &= (args.args_count == 3);
			passed &= (args.args[0] == 2);
			passed &= (args.args[1] == 3);
			passed &= (args.args[2] == 4);
			break;
		case 2:
			passed &= !rc;
			passed &= (args.args_count == 2);
			passed &= (args.args[0] == 5);
			passed &= (args.args[1] == 6);
			break;
		case 3:
			passed &= !rc;
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == 9);
			break;
		case 4:
			passed &= !rc;
			passed &= (args.args_count == 3);
			passed &= (args.args[0] == 10);
			passed &= (args.args[1] == 11);
			passed &= (args.args[2] == 12);
			break;
		case 5:
			passed &= !rc;
			passed &= (args.args_count == 2);
			passed &= (args.args[0] == 13);
			passed &= (args.args[1] == 14);
			break;
		case 6:
			passed &= !rc;
			passed &= (args.args_count == 1);
			passed &= (args.args[0] == 15);
			break;
		default:
			passed = false;
		}

906 907
		unittest(passed, "index %i - data error on node %pOF rc=%i\n",
			 i, args.np, rc);
908 909 910 911
	}
	of_node_put(np);
}

912
static const struct of_device_id match_node_table[] = {
913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
	{ .data = "A", .name = "name0", }, /* Name alone is lowest priority */
	{ .data = "B", .type = "type1", }, /* followed by type alone */

	{ .data = "Ca", .name = "name2", .type = "type1", }, /* followed by both together */
	{ .data = "Cb", .name = "name2", }, /* Only match when type doesn't match */
	{ .data = "Cc", .name = "name2", .type = "type2", },

	{ .data = "E", .compatible = "compat3" },
	{ .data = "G", .compatible = "compat2", },
	{ .data = "H", .compatible = "compat2", .name = "name5", },
	{ .data = "I", .compatible = "compat2", .type = "type1", },
	{ .data = "J", .compatible = "compat2", .type = "type1", .name = "name8", },
	{ .data = "K", .compatible = "compat2", .name = "name9", },
	{}
};

static struct {
	const char *path;
	const char *data;
} match_node_tests[] = {
	{ .path = "/testcase-data/match-node/name0", .data = "A", },
	{ .path = "/testcase-data/match-node/name1", .data = "B", },
	{ .path = "/testcase-data/match-node/a/name2", .data = "Ca", },
	{ .path = "/testcase-data/match-node/b/name2", .data = "Cb", },
	{ .path = "/testcase-data/match-node/c/name2", .data = "Cc", },
	{ .path = "/testcase-data/match-node/name3", .data = "E", },
	{ .path = "/testcase-data/match-node/name4", .data = "G", },
	{ .path = "/testcase-data/match-node/name5", .data = "H", },
	{ .path = "/testcase-data/match-node/name6", .data = "G", },
	{ .path = "/testcase-data/match-node/name7", .data = "I", },
	{ .path = "/testcase-data/match-node/name8", .data = "J", },
	{ .path = "/testcase-data/match-node/name9", .data = "K", },
};

947
static void __init of_unittest_match_node(void)
948 949 950 951 952 953 954 955
{
	struct device_node *np;
	const struct of_device_id *match;
	int i;

	for (i = 0; i < ARRAY_SIZE(match_node_tests); i++) {
		np = of_find_node_by_path(match_node_tests[i].path);
		if (!np) {
956
			unittest(0, "missing testcase node %s\n",
957 958 959 960 961 962
				match_node_tests[i].path);
			continue;
		}

		match = of_match_node(match_node_table, np);
		if (!match) {
963
			unittest(0, "%s didn't match anything\n",
964 965 966 967 968
				match_node_tests[i].path);
			continue;
		}

		if (strcmp(match->data, match_node_tests[i].data) != 0) {
969
			unittest(0, "%s got wrong match. expected %s, got %s\n",
970 971 972 973
				match_node_tests[i].path, match_node_tests[i].data,
				(const char *)match->data);
			continue;
		}
974
		unittest(1, "passed");
975 976 977
	}
}

978 979 980 981 982
static struct resource test_bus_res = {
	.start = 0xfffffff8,
	.end = 0xfffffff9,
	.flags = IORESOURCE_MEM,
};
983 984
static const struct platform_device_info test_bus_info = {
	.name = "unittest-bus",
985
};
986
static void __init of_unittest_platform_populate(void)
987
{
988 989
	int irq, rc;
	struct device_node *np, *child, *grandchild;
990
	struct platform_device *pdev, *test_bus;
991
	const struct of_device_id match[] = {
992 993 994
		{ .compatible = "test-device", },
		{}
	};
995 996

	np = of_find_node_by_path("/testcase-data");
997
	of_platform_default_populate(np, NULL, NULL);
998 999 1000 1001

	/* Test that a missing irq domain returns -EPROBE_DEFER */
	np = of_find_node_by_path("/testcase-data/testcase-device1");
	pdev = of_find_device_by_node(np);
1002
	unittest(pdev, "device 1 creation failed\n");
1003

1004
	irq = platform_get_irq(pdev, 0);
1005
	unittest(irq == -EPROBE_DEFER, "device deferred probe failed - %d\n", irq);
1006 1007 1008 1009

	/* Test that a parsing failure does not return -EPROBE_DEFER */
	np = of_find_node_by_path("/testcase-data/testcase-device2");
	pdev = of_find_device_by_node(np);
1010
	unittest(pdev, "device 2 creation failed\n");
1011
	irq = platform_get_irq(pdev, 0);
1012
	unittest(irq < 0 && irq != -EPROBE_DEFER, "device parsing error failed - %d\n", irq);
1013

1014
	np = of_find_node_by_path("/testcase-data/platform-tests");
1015
	unittest(np, "No testcase data in device tree\n");
1016
	if (!np)
1017 1018
		return;

1019 1020
	test_bus = platform_device_register_full(&test_bus_info);
	rc = PTR_ERR_OR_ZERO(test_bus);
1021
	unittest(!rc, "testbus registration failed; rc=%i\n", rc);
1022
	if (rc)
1023
		return;
1024
	test_bus->dev.of_node = np;
1025

1026 1027 1028 1029 1030 1031 1032 1033 1034
	/*
	 * Add a dummy resource to the test bus node after it is
	 * registered to catch problems with un-inserted resources. The
	 * DT code doesn't insert the resources, and it has caused the
	 * kernel to oops in the past. This makes sure the same bug
	 * doesn't crop up again.
	 */
	platform_device_add_resources(test_bus, &test_bus_res, 1);

1035
	of_platform_populate(np, match, NULL, &test_bus->dev);
1036 1037
	for_each_child_of_node(np, child) {
		for_each_child_of_node(child, grandchild)
1038
			unittest(of_find_device_by_node(grandchild),
1039 1040 1041
				 "Could not create device for node '%s'\n",
				 grandchild->name);
	}
1042

1043
	of_platform_depopulate(&test_bus->dev);
1044 1045
	for_each_child_of_node(np, child) {
		for_each_child_of_node(child, grandchild)
1046
			unittest(!of_find_device_by_node(grandchild),
1047 1048 1049 1050
				 "device didn't get destroyed '%s'\n",
				 grandchild->name);
	}

1051
	platform_device_unregister(test_bus);
1052
	of_node_put(np);
1053 1054
}

1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
/**
 *	update_node_properties - adds the properties
 *	of np into dup node (present in live tree) and
 *	updates parent of children of np to dup.
 *
 *	@np:	node already present in live tree
 *	@dup:	node present in live tree to be updated
 */
static void update_node_properties(struct device_node *np,
					struct device_node *dup)
{
	struct property *prop;
	struct device_node *child;

	for_each_property_of_node(np, prop)
		of_add_property(dup, prop);

	for_each_child_of_node(np, child)
		child->parent = dup;
}

/**
 *	attach_node_and_children - attaches nodes
 *	and its children to live tree
 *
 *	@np:	Node to attach to live tree
 */
static int attach_node_and_children(struct device_node *np)
{
G
Grant Likely 已提交
1084
	struct device_node *next, *dup, *child;
1085
	unsigned long flags;
1086
	const char *full_name;
1087

1088 1089 1090
	full_name = kasprintf(GFP_KERNEL, "%pOF", np);
	dup = of_find_node_by_path(full_name);
	kfree(full_name);
G
Grant Likely 已提交
1091 1092 1093 1094
	if (dup) {
		update_node_properties(np, dup);
		return 0;
	}
1095

G
Grant Likely 已提交
1096 1097
	child = np->child;
	np->child = NULL;
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108

	mutex_lock(&of_mutex);
	raw_spin_lock_irqsave(&devtree_lock, flags);
	np->sibling = np->parent->child;
	np->parent->child = np;
	of_node_clear_flag(np, OF_DETACHED);
	raw_spin_unlock_irqrestore(&devtree_lock, flags);

	__of_attach_node_sysfs(np);
	mutex_unlock(&of_mutex);

G
Grant Likely 已提交
1109 1110 1111 1112
	while (child) {
		next = child->sibling;
		attach_node_and_children(child);
		child = next;
1113 1114 1115 1116 1117 1118
	}

	return 0;
}

/**
1119
 *	unittest_data_add - Reads, copies data from
1120 1121
 *	linked tree and attaches it to the live tree
 */
1122
static int __init unittest_data_add(void)
1123
{
1124 1125
	void *unittest_data;
	struct device_node *unittest_data_node, *np;
1126 1127 1128 1129
	/*
	 * __dtb_testcases_begin[] and __dtb_testcases_end[] are magically
	 * created by cmd_dt_S_dtb in scripts/Makefile.lib
	 */
1130 1131 1132
	extern uint8_t __dtb_testcases_begin[];
	extern uint8_t __dtb_testcases_end[];
	const int size = __dtb_testcases_end - __dtb_testcases_begin;
1133
	int rc;
1134

1135
	if (!size) {
1136 1137 1138 1139 1140 1141
		pr_warn("%s: No testcase data to attach; not running tests\n",
			__func__);
		return -ENODATA;
	}

	/* creating copy */
1142
	unittest_data = kmemdup(__dtb_testcases_begin, size, GFP_KERNEL);
1143

1144 1145
	if (!unittest_data) {
		pr_warn("%s: Failed to allocate memory for unittest_data; "
1146 1147 1148
			"not running tests\n", __func__);
		return -ENOMEM;
	}
1149
	of_fdt_unflatten_tree(unittest_data, NULL, &unittest_data_node);
1150
	if (!unittest_data_node) {
1151 1152 1153
		pr_warn("%s: No tree to attach; not running tests\n", __func__);
		return -ENODATA;
	}
1154 1155

	/*
1156
	 * This lock normally encloses of_resolve_phandles()
1157 1158 1159
	 */
	of_overlay_mutex_lock();

1160
	rc = of_resolve_phandles(unittest_data_node);
1161 1162
	if (rc) {
		pr_err("%s: Failed to resolve phandles (rc=%i)\n", __func__, rc);
1163
		of_overlay_mutex_unlock();
1164 1165
		return -EINVAL;
	}
1166

G
Grant Likely 已提交
1167
	if (!of_root) {
1168
		of_root = unittest_data_node;
1169 1170 1171 1172
		for_each_of_allnodes(np)
			__of_attach_node_sysfs(np);
		of_aliases = of_find_node_by_path("/aliases");
		of_chosen = of_find_node_by_path("/chosen");
1173
		of_overlay_mutex_unlock();
1174 1175
		return 0;
	}
1176 1177

	/* attach the sub-tree to live tree */
1178
	np = unittest_data_node->child;
G
Grant Likely 已提交
1179 1180
	while (np) {
		struct device_node *next = np->sibling;
1181

G
Grant Likely 已提交
1182 1183 1184 1185
		np->parent = of_root;
		attach_node_and_children(np);
		np = next;
	}
1186 1187 1188

	of_overlay_mutex_unlock();

G
Grant Likely 已提交
1189
	return 0;
1190 1191
}

1192
#ifdef CONFIG_OF_OVERLAY
1193
static int __init overlay_data_apply(const char *overlay_name, int *overlay_id);
1194

1195
static int unittest_probe(struct platform_device *pdev)
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;

	if (np == NULL) {
		dev_err(dev, "No OF data for device\n");
		return -EINVAL;

	}

1206
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1207 1208 1209

	of_platform_populate(np, NULL, NULL, &pdev->dev);

1210 1211 1212
	return 0;
}

1213
static int unittest_remove(struct platform_device *pdev)
1214 1215 1216 1217
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;

1218
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1219 1220 1221
	return 0;
}

1222
static const struct of_device_id unittest_match[] = {
1223
	{ .compatible = "unittest", },
1224 1225 1226
	{},
};

1227 1228 1229
static struct platform_driver unittest_driver = {
	.probe			= unittest_probe,
	.remove			= unittest_remove,
1230
	.driver = {
1231 1232
		.name		= "unittest",
		.of_match_table	= of_match_ptr(unittest_match),
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
	},
};

/* get the platform device instantiated at the path */
static struct platform_device *of_path_to_platform_device(const char *path)
{
	struct device_node *np;
	struct platform_device *pdev;

	np = of_find_node_by_path(path);
	if (np == NULL)
		return NULL;

	pdev = of_find_device_by_node(np);
	of_node_put(np);

	return pdev;
}

/* find out if a platform device exists at that path */
static int of_path_platform_device_exists(const char *path)
{
	struct platform_device *pdev;

	pdev = of_path_to_platform_device(path);
	platform_device_put(pdev);
	return pdev != NULL;
}

A
Arnd Bergmann 已提交
1262
#if IS_BUILTIN(CONFIG_I2C)
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303

/* get the i2c client device instantiated at the path */
static struct i2c_client *of_path_to_i2c_client(const char *path)
{
	struct device_node *np;
	struct i2c_client *client;

	np = of_find_node_by_path(path);
	if (np == NULL)
		return NULL;

	client = of_find_i2c_device_by_node(np);
	of_node_put(np);

	return client;
}

/* find out if a i2c client device exists at that path */
static int of_path_i2c_client_exists(const char *path)
{
	struct i2c_client *client;

	client = of_path_to_i2c_client(path);
	if (client)
		put_device(&client->dev);
	return client != NULL;
}
#else
static int of_path_i2c_client_exists(const char *path)
{
	return 0;
}
#endif

enum overlay_type {
	PDEV_OVERLAY,
	I2C_OVERLAY
};

static int of_path_device_type_exists(const char *path,
		enum overlay_type ovtype)
1304
{
1305 1306 1307 1308 1309 1310 1311 1312 1313
	switch (ovtype) {
	case PDEV_OVERLAY:
		return of_path_platform_device_exists(path);
	case I2C_OVERLAY:
		return of_path_i2c_client_exists(path);
	}
	return 0;
}

1314
static const char *unittest_path(int nr, enum overlay_type ovtype)
1315 1316
{
	const char *base;
1317 1318
	static char buf[256];

1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
	switch (ovtype) {
	case PDEV_OVERLAY:
		base = "/testcase-data/overlay-node/test-bus";
		break;
	case I2C_OVERLAY:
		base = "/testcase-data/overlay-node/test-bus/i2c-test-bus";
		break;
	default:
		buf[0] = '\0';
		return buf;
	}
1330
	snprintf(buf, sizeof(buf) - 1, "%s/test-unittest%d", base, nr);
1331 1332 1333 1334
	buf[sizeof(buf) - 1] = '\0';
	return buf;
}

1335
static int of_unittest_device_exists(int unittest_nr, enum overlay_type ovtype)
1336 1337 1338
{
	const char *path;

1339
	path = unittest_path(unittest_nr, ovtype);
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349

	switch (ovtype) {
	case PDEV_OVERLAY:
		return of_path_platform_device_exists(path);
	case I2C_OVERLAY:
		return of_path_i2c_client_exists(path);
	}
	return 0;
}

1350
static const char *overlay_name_from_nr(int nr)
1351 1352 1353 1354
{
	static char buf[256];

	snprintf(buf, sizeof(buf) - 1,
1355
		"overlay_%d", nr);
1356 1357 1358 1359 1360 1361 1362
	buf[sizeof(buf) - 1] = '\0';

	return buf;
}

static const char *bus_path = "/testcase-data/overlay-node/test-bus";

1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
/* it is guaranteed that overlay ids are assigned in sequence */
#define MAX_UNITTEST_OVERLAYS	256
static unsigned long overlay_id_bits[BITS_TO_LONGS(MAX_UNITTEST_OVERLAYS)];
static int overlay_first_id = -1;

static void of_unittest_track_overlay(int id)
{
	if (overlay_first_id < 0)
		overlay_first_id = id;
	id -= overlay_first_id;

	/* we shouldn't need that many */
	BUG_ON(id >= MAX_UNITTEST_OVERLAYS);
	overlay_id_bits[BIT_WORD(id)] |= BIT_MASK(id);
}

static void of_unittest_untrack_overlay(int id)
{
	if (overlay_first_id < 0)
		return;
	id -= overlay_first_id;
	BUG_ON(id >= MAX_UNITTEST_OVERLAYS);
	overlay_id_bits[BIT_WORD(id)] &= ~BIT_MASK(id);
}

static void of_unittest_destroy_tracked_overlays(void)
{
1390
	int id, ret, defers, ovcs_id;
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402

	if (overlay_first_id < 0)
		return;

	/* try until no defers */
	do {
		defers = 0;
		/* remove in reverse order */
		for (id = MAX_UNITTEST_OVERLAYS - 1; id >= 0; id--) {
			if (!(overlay_id_bits[BIT_WORD(id)] & BIT_MASK(id)))
				continue;

1403 1404
			ovcs_id = id + overlay_first_id;
			ret = of_overlay_remove(&ovcs_id);
1405 1406 1407 1408 1409
			if (ret == -ENODEV) {
				pr_warn("%s: no overlay to destroy for #%d\n",
					__func__, id + overlay_first_id);
				continue;
			}
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
			if (ret != 0) {
				defers++;
				pr_warn("%s: overlay destroy failed for #%d\n",
					__func__, id + overlay_first_id);
				continue;
			}

			overlay_id_bits[BIT_WORD(id)] &= ~BIT_MASK(id);
		}
	} while (defers > 0);
}

1422
static int __init of_unittest_apply_overlay(int overlay_nr, int unittest_nr,
1423 1424
		int *overlay_id)
{
1425
	const char *overlay_name;
1426

1427
	overlay_name = overlay_name_from_nr(overlay_nr);
1428

1429
	if (!overlay_data_apply(overlay_name, overlay_id)) {
1430 1431
		unittest(0, "could not apply overlay \"%s\"\n",
				overlay_name);
1432
		return -EFAULT;
1433
	}
1434
	of_unittest_track_overlay(*overlay_id);
1435

1436
	return 0;
1437 1438 1439
}

/* apply an overlay while checking before and after states */
1440 1441 1442
static int __init of_unittest_apply_overlay_check(int overlay_nr,
		int unittest_nr, int before, int after,
		enum overlay_type ovtype)
1443
{
1444
	int ret, ovcs_id;
1445

1446 1447
	/* unittest device must not be in before state */
	if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
1448 1449
		unittest(0, "%s with device @\"%s\" %s\n",
				overlay_name_from_nr(overlay_nr),
1450
				unittest_path(unittest_nr, ovtype),
1451 1452 1453 1454
				!before ? "enabled" : "disabled");
		return -EINVAL;
	}

1455 1456
	ovcs_id = 0;
	ret = of_unittest_apply_overlay(overlay_nr, unittest_nr, &ovcs_id);
1457
	if (ret != 0) {
1458
		/* of_unittest_apply_overlay already called unittest() */
1459 1460 1461
		return ret;
	}

1462 1463
	/* unittest device must be to set to after state */
	if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
1464 1465
		unittest(0, "%s failed to create @\"%s\" %s\n",
				overlay_name_from_nr(overlay_nr),
1466
				unittest_path(unittest_nr, ovtype),
1467 1468 1469 1470 1471 1472 1473 1474
				!after ? "enabled" : "disabled");
		return -EINVAL;
	}

	return 0;
}

/* apply an overlay and then revert it while checking before, after states */
1475
static int __init of_unittest_apply_revert_overlay_check(int overlay_nr,
1476
		int unittest_nr, int before, int after,
1477
		enum overlay_type ovtype)
1478
{
1479
	int ret, ovcs_id;
1480

1481 1482
	/* unittest device must be in before state */
	if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
1483 1484
		unittest(0, "%s with device @\"%s\" %s\n",
				overlay_name_from_nr(overlay_nr),
1485
				unittest_path(unittest_nr, ovtype),
1486 1487 1488 1489 1490
				!before ? "enabled" : "disabled");
		return -EINVAL;
	}

	/* apply the overlay */
1491 1492
	ovcs_id = 0;
	ret = of_unittest_apply_overlay(overlay_nr, unittest_nr, &ovcs_id);
1493
	if (ret != 0) {
1494
		/* of_unittest_apply_overlay already called unittest() */
1495 1496 1497
		return ret;
	}

1498 1499
	/* unittest device must be in after state */
	if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
1500 1501
		unittest(0, "%s failed to create @\"%s\" %s\n",
				overlay_name_from_nr(overlay_nr),
1502
				unittest_path(unittest_nr, ovtype),
1503 1504 1505 1506
				!after ? "enabled" : "disabled");
		return -EINVAL;
	}

1507
	ret = of_overlay_remove(&ovcs_id);
1508
	if (ret != 0) {
1509 1510
		unittest(0, "%s failed to be destroyed @\"%s\"\n",
				overlay_name_from_nr(overlay_nr),
1511
				unittest_path(unittest_nr, ovtype));
1512 1513 1514
		return ret;
	}

1515 1516
	/* unittest device must be again in before state */
	if (of_unittest_device_exists(unittest_nr, PDEV_OVERLAY) != before) {
1517 1518
		unittest(0, "%s with device @\"%s\" %s\n",
				overlay_name_from_nr(overlay_nr),
1519
				unittest_path(unittest_nr, ovtype),
1520 1521 1522 1523 1524 1525 1526 1527
				!before ? "enabled" : "disabled");
		return -EINVAL;
	}

	return 0;
}

/* test activation of device */
1528
static void __init of_unittest_overlay_0(void)
1529 1530
{
	/* device should enable */
1531
	if (of_unittest_apply_overlay_check(0, 0, 0, 1, PDEV_OVERLAY))
1532 1533
		return;

1534
	unittest(1, "overlay test %d passed\n", 0);
1535 1536 1537
}

/* test deactivation of device */
1538
static void __init of_unittest_overlay_1(void)
1539 1540
{
	/* device should disable */
1541
	if (of_unittest_apply_overlay_check(1, 1, 1, 0, PDEV_OVERLAY))
1542 1543
		return;

1544
	unittest(1, "overlay test %d passed\n", 1);
1545 1546 1547
}

/* test activation of device */
1548
static void __init of_unittest_overlay_2(void)
1549 1550
{
	/* device should enable */
1551
	if (of_unittest_apply_overlay_check(2, 2, 0, 1, PDEV_OVERLAY))
1552 1553
		return;

1554
	unittest(1, "overlay test %d passed\n", 2);
1555 1556 1557
}

/* test deactivation of device */
1558
static void __init of_unittest_overlay_3(void)
1559 1560
{
	/* device should disable */
1561
	if (of_unittest_apply_overlay_check(3, 3, 1, 0, PDEV_OVERLAY))
1562 1563
		return;

1564
	unittest(1, "overlay test %d passed\n", 3);
1565 1566 1567
}

/* test activation of a full device node */
1568
static void __init of_unittest_overlay_4(void)
1569 1570
{
	/* device should disable */
1571
	if (of_unittest_apply_overlay_check(4, 4, 0, 1, PDEV_OVERLAY))
1572 1573
		return;

1574
	unittest(1, "overlay test %d passed\n", 4);
1575 1576 1577
}

/* test overlay apply/revert sequence */
1578
static void __init of_unittest_overlay_5(void)
1579 1580
{
	/* device should disable */
1581
	if (of_unittest_apply_revert_overlay_check(5, 5, 0, 1, PDEV_OVERLAY))
1582 1583
		return;

1584
	unittest(1, "overlay test %d passed\n", 5);
1585 1586 1587
}

/* test overlay application in sequence */
1588
static void __init of_unittest_overlay_6(void)
1589
{
1590
	int i, ov_id[2], ovcs_id;
1591
	int overlay_nr = 6, unittest_nr = 6;
1592
	int before = 0, after = 1;
1593
	const char *overlay_name;
1594

1595
	/* unittest device must be in before state */
1596
	for (i = 0; i < 2; i++) {
1597
		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
1598
				!= before) {
1599 1600
			unittest(0, "%s with device @\"%s\" %s\n",
					overlay_name_from_nr(overlay_nr + i),
1601
					unittest_path(unittest_nr + i,
1602
						PDEV_OVERLAY),
1603 1604 1605 1606 1607 1608 1609 1610
					!before ? "enabled" : "disabled");
			return;
		}
	}

	/* apply the overlays */
	for (i = 0; i < 2; i++) {

1611
		overlay_name = overlay_name_from_nr(overlay_nr + i);
1612

1613
		if (!overlay_data_apply(overlay_name, &ovcs_id)) {
1614 1615
			unittest(0, "could not apply overlay \"%s\"\n",
					overlay_name);
1616 1617
			return;
		}
1618
		ov_id[i] = ovcs_id;
1619
		of_unittest_track_overlay(ov_id[i]);
1620 1621 1622
	}

	for (i = 0; i < 2; i++) {
1623 1624
		/* unittest device must be in after state */
		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
1625
				!= after) {
1626
			unittest(0, "overlay @\"%s\" failed @\"%s\" %s\n",
1627
					overlay_name_from_nr(overlay_nr + i),
1628
					unittest_path(unittest_nr + i,
1629
						PDEV_OVERLAY),
1630 1631 1632 1633 1634 1635
					!after ? "enabled" : "disabled");
			return;
		}
	}

	for (i = 1; i >= 0; i--) {
1636
		ovcs_id = ov_id[i];
1637
		if (of_overlay_remove(&ovcs_id)) {
1638 1639
			unittest(0, "%s failed destroy @\"%s\"\n",
					overlay_name_from_nr(overlay_nr + i),
1640
					unittest_path(unittest_nr + i,
1641
						PDEV_OVERLAY));
1642 1643
			return;
		}
1644
		of_unittest_untrack_overlay(ov_id[i]);
1645 1646 1647
	}

	for (i = 0; i < 2; i++) {
1648 1649
		/* unittest device must be again in before state */
		if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
1650
				!= before) {
1651 1652
			unittest(0, "%s with device @\"%s\" %s\n",
					overlay_name_from_nr(overlay_nr + i),
1653
					unittest_path(unittest_nr + i,
1654
						PDEV_OVERLAY),
1655 1656 1657 1658 1659
					!before ? "enabled" : "disabled");
			return;
		}
	}

1660
	unittest(1, "overlay test %d passed\n", 6);
1661 1662 1663
}

/* test overlay application in sequence */
1664
static void __init of_unittest_overlay_8(void)
1665
{
1666
	int i, ov_id[2], ovcs_id;
1667
	int overlay_nr = 8, unittest_nr = 8;
1668
	const char *overlay_name;
1669 1670 1671 1672 1673 1674

	/* we don't care about device state in this test */

	/* apply the overlays */
	for (i = 0; i < 2; i++) {

1675
		overlay_name = overlay_name_from_nr(overlay_nr + i);
1676

1677
		if (!overlay_data_apply(overlay_name, &ovcs_id)) {
1678 1679
			unittest(0, "could not apply overlay \"%s\"\n",
					overlay_name);
1680 1681
			return;
		}
1682
		ov_id[i] = ovcs_id;
1683
		of_unittest_track_overlay(ov_id[i]);
1684 1685 1686
	}

	/* now try to remove first overlay (it should fail) */
1687
	ovcs_id = ov_id[0];
1688
	if (!of_overlay_remove(&ovcs_id)) {
1689 1690
		unittest(0, "%s was destroyed @\"%s\"\n",
				overlay_name_from_nr(overlay_nr + 0),
1691
				unittest_path(unittest_nr,
1692
					PDEV_OVERLAY));
1693 1694 1695 1696 1697
		return;
	}

	/* removing them in order should work */
	for (i = 1; i >= 0; i--) {
1698
		ovcs_id = ov_id[i];
1699
		if (of_overlay_remove(&ovcs_id)) {
1700 1701
			unittest(0, "%s not destroyed @\"%s\"\n",
					overlay_name_from_nr(overlay_nr + i),
1702
					unittest_path(unittest_nr,
1703
						PDEV_OVERLAY));
1704 1705
			return;
		}
1706
		of_unittest_untrack_overlay(ov_id[i]);
1707 1708
	}

1709
	unittest(1, "overlay test %d passed\n", 8);
1710 1711
}

1712
/* test insertion of a bus with parent devices */
1713
static void __init of_unittest_overlay_10(void)
1714 1715 1716 1717 1718
{
	int ret;
	char *child_path;

	/* device should disable */
1719 1720
	ret = of_unittest_apply_overlay_check(10, 10, 0, 1, PDEV_OVERLAY);
	if (unittest(ret == 0,
1721
			"overlay test %d failed; overlay application\n", 10))
1722 1723
		return;

1724 1725 1726
	child_path = kasprintf(GFP_KERNEL, "%s/test-unittest101",
			unittest_path(10, PDEV_OVERLAY));
	if (unittest(child_path, "overlay test %d failed; kasprintf\n", 10))
1727 1728
		return;

1729
	ret = of_path_device_type_exists(child_path, PDEV_OVERLAY);
1730
	kfree(child_path);
1731 1732

	unittest(ret, "overlay test %d failed; no child device\n", 10);
1733 1734 1735
}

/* test insertion of a bus with parent devices (and revert) */
1736
static void __init of_unittest_overlay_11(void)
1737 1738 1739 1740
{
	int ret;

	/* device should disable */
1741
	ret = of_unittest_apply_revert_overlay_check(11, 11, 0, 1,
1742
			PDEV_OVERLAY);
1743
	unittest(ret == 0, "overlay test %d failed; overlay apply\n", 11);
1744 1745
}

A
Arnd Bergmann 已提交
1746
#if IS_BUILTIN(CONFIG_I2C) && IS_ENABLED(CONFIG_OF_OVERLAY)
1747

1748
struct unittest_i2c_bus_data {
1749 1750 1751 1752
	struct platform_device	*pdev;
	struct i2c_adapter	adap;
};

1753
static int unittest_i2c_master_xfer(struct i2c_adapter *adap,
1754 1755
		struct i2c_msg *msgs, int num)
{
1756
	struct unittest_i2c_bus_data *std = i2c_get_adapdata(adap);
1757 1758 1759 1760 1761 1762

	(void)std;

	return num;
}

1763
static u32 unittest_i2c_functionality(struct i2c_adapter *adap)
1764 1765 1766 1767
{
	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
}

1768 1769 1770
static const struct i2c_algorithm unittest_i2c_algo = {
	.master_xfer	= unittest_i2c_master_xfer,
	.functionality	= unittest_i2c_functionality,
1771 1772
};

1773
static int unittest_i2c_bus_probe(struct platform_device *pdev)
1774 1775 1776
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;
1777
	struct unittest_i2c_bus_data *std;
1778 1779 1780 1781 1782 1783 1784 1785 1786
	struct i2c_adapter *adap;
	int ret;

	if (np == NULL) {
		dev_err(dev, "No OF data for device\n");
		return -EINVAL;

	}

1787
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1788 1789 1790

	std = devm_kzalloc(dev, sizeof(*std), GFP_KERNEL);
	if (!std) {
1791
		dev_err(dev, "Failed to allocate unittest i2c data\n");
1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
		return -ENOMEM;
	}

	/* link them together */
	std->pdev = pdev;
	platform_set_drvdata(pdev, std);

	adap = &std->adap;
	i2c_set_adapdata(adap, std);
	adap->nr = -1;
	strlcpy(adap->name, pdev->name, sizeof(adap->name));
	adap->class = I2C_CLASS_DEPRECATED;
1804
	adap->algo = &unittest_i2c_algo;
1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
	adap->dev.parent = dev;
	adap->dev.of_node = dev->of_node;
	adap->timeout = 5 * HZ;
	adap->retries = 3;

	ret = i2c_add_numbered_adapter(adap);
	if (ret != 0) {
		dev_err(dev, "Failed to add I2C adapter\n");
		return ret;
	}

	return 0;
}

1819
static int unittest_i2c_bus_remove(struct platform_device *pdev)
1820 1821 1822
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;
1823
	struct unittest_i2c_bus_data *std = platform_get_drvdata(pdev);
1824

1825
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1826 1827 1828 1829 1830
	i2c_del_adapter(&std->adap);

	return 0;
}

1831
static const struct of_device_id unittest_i2c_bus_match[] = {
1832
	{ .compatible = "unittest-i2c-bus", },
1833 1834 1835
	{},
};

1836 1837 1838
static struct platform_driver unittest_i2c_bus_driver = {
	.probe			= unittest_i2c_bus_probe,
	.remove			= unittest_i2c_bus_remove,
1839
	.driver = {
1840 1841
		.name		= "unittest-i2c-bus",
		.of_match_table	= of_match_ptr(unittest_i2c_bus_match),
1842 1843 1844
	},
};

1845
static int unittest_i2c_dev_probe(struct i2c_client *client,
1846 1847 1848 1849 1850 1851 1852 1853 1854 1855
		const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct device_node *np = client->dev.of_node;

	if (!np) {
		dev_err(dev, "No OF node\n");
		return -EINVAL;
	}

1856
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1857 1858 1859 1860

	return 0;
};

1861
static int unittest_i2c_dev_remove(struct i2c_client *client)
1862 1863 1864 1865
{
	struct device *dev = &client->dev;
	struct device_node *np = client->dev.of_node;

1866
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1867 1868 1869
	return 0;
}

1870 1871
static const struct i2c_device_id unittest_i2c_dev_id[] = {
	{ .name = "unittest-i2c-dev" },
1872 1873 1874
	{ }
};

1875
static struct i2c_driver unittest_i2c_dev_driver = {
1876
	.driver = {
1877
		.name = "unittest-i2c-dev",
1878
	},
1879 1880 1881
	.probe = unittest_i2c_dev_probe,
	.remove = unittest_i2c_dev_remove,
	.id_table = unittest_i2c_dev_id,
1882 1883
};

A
Arnd Bergmann 已提交
1884
#if IS_BUILTIN(CONFIG_I2C_MUX)
1885

1886
static int unittest_i2c_mux_select_chan(struct i2c_mux_core *muxc, u32 chan)
1887 1888 1889 1890
{
	return 0;
}

1891
static int unittest_i2c_mux_probe(struct i2c_client *client,
1892 1893
		const struct i2c_device_id *id)
{
1894
	int i, nchans;
1895 1896 1897
	struct device *dev = &client->dev;
	struct i2c_adapter *adap = to_i2c_adapter(dev->parent);
	struct device_node *np = client->dev.of_node, *child;
1898
	struct i2c_mux_core *muxc;
1899 1900
	u32 reg, max_reg;

1901
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1902 1903 1904 1905 1906 1907 1908 1909

	if (!np) {
		dev_err(dev, "No OF node\n");
		return -EINVAL;
	}

	max_reg = (u32)-1;
	for_each_child_of_node(np, child) {
1910
		if (of_property_read_u32(child, "reg", &reg))
1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
			continue;
		if (max_reg == (u32)-1 || reg > max_reg)
			max_reg = reg;
	}
	nchans = max_reg == (u32)-1 ? 0 : max_reg + 1;
	if (nchans == 0) {
		dev_err(dev, "No channels\n");
		return -EINVAL;
	}

1921 1922 1923
	muxc = i2c_mux_alloc(adap, dev, nchans, 0, 0,
			     unittest_i2c_mux_select_chan, NULL);
	if (!muxc)
1924 1925
		return -ENOMEM;
	for (i = 0; i < nchans; i++) {
1926
		if (i2c_mux_add_adapter(muxc, 0, i, 0)) {
1927
			dev_err(dev, "Failed to register mux #%d\n", i);
1928
			i2c_mux_del_adapters(muxc);
1929 1930 1931 1932
			return -ENODEV;
		}
	}

1933
	i2c_set_clientdata(client, muxc);
1934 1935 1936 1937

	return 0;
};

1938
static int unittest_i2c_mux_remove(struct i2c_client *client)
1939 1940 1941
{
	struct device *dev = &client->dev;
	struct device_node *np = client->dev.of_node;
1942
	struct i2c_mux_core *muxc = i2c_get_clientdata(client);
1943

1944
	dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1945
	i2c_mux_del_adapters(muxc);
1946 1947 1948
	return 0;
}

1949 1950
static const struct i2c_device_id unittest_i2c_mux_id[] = {
	{ .name = "unittest-i2c-mux" },
1951 1952 1953
	{ }
};

1954
static struct i2c_driver unittest_i2c_mux_driver = {
1955
	.driver = {
1956
		.name = "unittest-i2c-mux",
1957
	},
1958 1959 1960
	.probe = unittest_i2c_mux_probe,
	.remove = unittest_i2c_mux_remove,
	.id_table = unittest_i2c_mux_id,
1961 1962 1963 1964
};

#endif

1965
static int of_unittest_overlay_i2c_init(void)
1966 1967 1968
{
	int ret;

1969 1970 1971
	ret = i2c_add_driver(&unittest_i2c_dev_driver);
	if (unittest(ret == 0,
			"could not register unittest i2c device driver\n"))
1972 1973
		return ret;

1974 1975 1976
	ret = platform_driver_register(&unittest_i2c_bus_driver);
	if (unittest(ret == 0,
			"could not register unittest i2c bus driver\n"))
1977 1978
		return ret;

A
Arnd Bergmann 已提交
1979
#if IS_BUILTIN(CONFIG_I2C_MUX)
1980 1981 1982
	ret = i2c_add_driver(&unittest_i2c_mux_driver);
	if (unittest(ret == 0,
			"could not register unittest i2c mux driver\n"))
1983 1984 1985 1986 1987 1988
		return ret;
#endif

	return 0;
}

1989
static void of_unittest_overlay_i2c_cleanup(void)
1990
{
A
Arnd Bergmann 已提交
1991
#if IS_BUILTIN(CONFIG_I2C_MUX)
1992
	i2c_del_driver(&unittest_i2c_mux_driver);
1993
#endif
1994 1995
	platform_driver_unregister(&unittest_i2c_bus_driver);
	i2c_del_driver(&unittest_i2c_dev_driver);
1996 1997
}

1998
static void __init of_unittest_overlay_i2c_12(void)
1999 2000
{
	/* device should enable */
2001
	if (of_unittest_apply_overlay_check(12, 12, 0, 1, I2C_OVERLAY))
2002 2003
		return;

2004
	unittest(1, "overlay test %d passed\n", 12);
2005 2006 2007
}

/* test deactivation of device */
2008
static void __init of_unittest_overlay_i2c_13(void)
2009 2010
{
	/* device should disable */
2011
	if (of_unittest_apply_overlay_check(13, 13, 1, 0, I2C_OVERLAY))
2012
		return;
2013

2014
	unittest(1, "overlay test %d passed\n", 13);
2015 2016 2017
}

/* just check for i2c mux existence */
2018
static void of_unittest_overlay_i2c_14(void)
2019
{
2020 2021
}

2022
static void __init of_unittest_overlay_i2c_15(void)
2023 2024
{
	/* device should enable */
2025
	if (of_unittest_apply_overlay_check(15, 15, 0, 1, I2C_OVERLAY))
2026 2027
		return;

2028
	unittest(1, "overlay test %d passed\n", 15);
2029 2030 2031 2032
}

#else

2033 2034
static inline void of_unittest_overlay_i2c_14(void) { }
static inline void of_unittest_overlay_i2c_15(void) { }
2035 2036 2037

#endif

2038
static void __init of_unittest_overlay(void)
2039 2040 2041
{
	struct device_node *bus_np = NULL;

2042
	if (platform_driver_register(&unittest_driver)) {
2043
		unittest(0, "could not register unittest driver\n");
2044 2045 2046 2047 2048
		goto out;
	}

	bus_np = of_find_node_by_path(bus_path);
	if (bus_np == NULL) {
2049
		unittest(0, "could not find bus_path \"%s\"\n", bus_path);
2050 2051 2052
		goto out;
	}

2053
	if (of_platform_default_populate(bus_np, NULL, NULL)) {
2054
		unittest(0, "could not populate bus @ \"%s\"\n", bus_path);
2055 2056 2057
		goto out;
	}

2058 2059 2060
	if (!of_unittest_device_exists(100, PDEV_OVERLAY)) {
		unittest(0, "could not find unittest0 @ \"%s\"\n",
				unittest_path(100, PDEV_OVERLAY));
2061 2062 2063
		goto out;
	}

2064 2065 2066
	if (of_unittest_device_exists(101, PDEV_OVERLAY)) {
		unittest(0, "unittest1 @ \"%s\" should not exist\n",
				unittest_path(101, PDEV_OVERLAY));
2067 2068 2069
		goto out;
	}

2070
	unittest(1, "basic infrastructure of overlays passed");
2071 2072

	/* tests in sequence */
2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
	of_unittest_overlay_0();
	of_unittest_overlay_1();
	of_unittest_overlay_2();
	of_unittest_overlay_3();
	of_unittest_overlay_4();
	of_unittest_overlay_5();
	of_unittest_overlay_6();
	of_unittest_overlay_8();

	of_unittest_overlay_10();
	of_unittest_overlay_11();
2084

A
Arnd Bergmann 已提交
2085
#if IS_BUILTIN(CONFIG_I2C)
2086
	if (unittest(of_unittest_overlay_i2c_init() == 0, "i2c init failed\n"))
2087 2088
		goto out;

2089 2090 2091 2092
	of_unittest_overlay_i2c_12();
	of_unittest_overlay_i2c_13();
	of_unittest_overlay_i2c_14();
	of_unittest_overlay_i2c_15();
2093

2094
	of_unittest_overlay_i2c_cleanup();
2095 2096
#endif

2097 2098
	of_unittest_destroy_tracked_overlays();

2099 2100 2101 2102 2103
out:
	of_node_put(bus_np);
}

#else
2104
static inline void __init of_unittest_overlay(void) { }
2105 2106
#endif

2107 2108
#ifdef CONFIG_OF_OVERLAY

2109 2110 2111 2112 2113 2114 2115 2116 2117
/*
 * __dtb_ot_begin[] and __dtb_ot_end[] are created by cmd_dt_S_dtb
 * in scripts/Makefile.lib
 */

#define OVERLAY_INFO_EXTERN(name) \
	extern uint8_t __dtb_##name##_begin[]; \
	extern uint8_t __dtb_##name##_end[]

2118 2119 2120 2121 2122
#define OVERLAY_INFO(overlay_name, expected)             \
{	.dtb_begin       = __dtb_##overlay_name##_begin, \
	.dtb_end         = __dtb_##overlay_name##_end,   \
	.expected_result = expected,                     \
	.name            = #overlay_name,                \
2123 2124 2125
}

struct overlay_info {
2126 2127 2128 2129 2130
	uint8_t		*dtb_begin;
	uint8_t		*dtb_end;
	int		expected_result;
	int		overlay_id;
	char		*name;
2131 2132 2133 2134
};

OVERLAY_INFO_EXTERN(overlay_base);
OVERLAY_INFO_EXTERN(overlay);
2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149
OVERLAY_INFO_EXTERN(overlay_0);
OVERLAY_INFO_EXTERN(overlay_1);
OVERLAY_INFO_EXTERN(overlay_2);
OVERLAY_INFO_EXTERN(overlay_3);
OVERLAY_INFO_EXTERN(overlay_4);
OVERLAY_INFO_EXTERN(overlay_5);
OVERLAY_INFO_EXTERN(overlay_6);
OVERLAY_INFO_EXTERN(overlay_7);
OVERLAY_INFO_EXTERN(overlay_8);
OVERLAY_INFO_EXTERN(overlay_9);
OVERLAY_INFO_EXTERN(overlay_10);
OVERLAY_INFO_EXTERN(overlay_11);
OVERLAY_INFO_EXTERN(overlay_12);
OVERLAY_INFO_EXTERN(overlay_13);
OVERLAY_INFO_EXTERN(overlay_15);
2150
OVERLAY_INFO_EXTERN(overlay_bad_phandle);
2151
OVERLAY_INFO_EXTERN(overlay_bad_symbol);
2152 2153 2154 2155 2156

/* order of entries is hard-coded into users of overlays[] */
static struct overlay_info overlays[] = {
	OVERLAY_INFO(overlay_base, -9999),
	OVERLAY_INFO(overlay, 0),
2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
	OVERLAY_INFO(overlay_0, 0),
	OVERLAY_INFO(overlay_1, 0),
	OVERLAY_INFO(overlay_2, 0),
	OVERLAY_INFO(overlay_3, 0),
	OVERLAY_INFO(overlay_4, 0),
	OVERLAY_INFO(overlay_5, 0),
	OVERLAY_INFO(overlay_6, 0),
	OVERLAY_INFO(overlay_7, 0),
	OVERLAY_INFO(overlay_8, 0),
	OVERLAY_INFO(overlay_9, 0),
	OVERLAY_INFO(overlay_10, 0),
	OVERLAY_INFO(overlay_11, 0),
	OVERLAY_INFO(overlay_12, 0),
	OVERLAY_INFO(overlay_13, 0),
	OVERLAY_INFO(overlay_15, 0),
2172
	OVERLAY_INFO(overlay_bad_phandle, -EINVAL),
2173
	OVERLAY_INFO(overlay_bad_symbol, -EINVAL),
2174 2175 2176 2177 2178
	{}
};

static struct device_node *overlay_base_root;

2179 2180 2181 2182 2183
static void * __init dt_alloc_memory(u64 size, u64 align)
{
	return memblock_virt_alloc(size, align);
}

2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
/*
 * Create base device tree for the overlay unittest.
 *
 * This is called from very early boot code.
 *
 * Do as much as possible the same way as done in __unflatten_device_tree
 * and other early boot steps for the normal FDT so that the overlay base
 * unflattened tree will have the same characteristics as the real tree
 * (such as having memory allocated by the early allocator).  The goal
 * is to test "the real thing" as much as possible, and test "test setup
 * code" as little as possible.
 *
 * Have to stop before resolving phandles, because that uses kmalloc.
 */
void __init unittest_unflatten_overlay_base(void)
{
	struct overlay_info *info;
	u32 data_size;
2202
	void *new_fdt;
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223
	u32 size;

	info = &overlays[0];

	if (info->expected_result != -9999) {
		pr_err("No dtb 'overlay_base' to attach\n");
		return;
	}

	data_size = info->dtb_end - info->dtb_begin;
	if (!data_size) {
		pr_err("No dtb 'overlay_base' to attach\n");
		return;
	}

	size = fdt_totalsize(info->dtb_begin);
	if (size != data_size) {
		pr_err("dtb 'overlay_base' header totalsize != actual size");
		return;
	}

2224 2225
	new_fdt = dt_alloc_memory(size, roundup_pow_of_two(FDT_V17_SIZE));
	if (!new_fdt) {
2226 2227 2228 2229
		pr_err("alloc for dtb 'overlay_base' failed");
		return;
	}

2230
	memcpy(new_fdt, info->dtb_begin, size);
2231

2232
	__unflatten_device_tree(new_fdt, NULL, &overlay_base_root,
2233
				dt_alloc_memory, true);
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246
}

/*
 * The purpose of of_unittest_overlay_data_add is to add an
 * overlay in the normal fashion.  This is a test of the whole
 * picture, instead of testing individual elements.
 *
 * A secondary purpose is to be able to verify that the contents of
 * /proc/device-tree/ contains the updated structure and values from
 * the overlay.  That must be verified separately in user space.
 *
 * Return 0 on unexpected error.
 */
2247
static int __init overlay_data_apply(const char *overlay_name, int *overlay_id)
2248 2249
{
	struct overlay_info *info;
2250
	int found = 0;
2251 2252 2253 2254
	int k;
	int ret;
	u32 size;

2255 2256 2257
	for (k = 0, info = overlays; info && info->name; info++, k++) {
		if (!strcmp(overlay_name, info->name)) {
			found = 1;
2258
			break;
2259
		}
2260
	}
2261 2262
	if (!found) {
		pr_err("no overlay data for %s\n", overlay_name);
2263
		return 0;
2264
	}
2265 2266

	size = info->dtb_end - info->dtb_begin;
2267
	if (!size)
2268
		pr_err("no overlay data for %s\n", overlay_name);
2269

2270 2271 2272 2273 2274
	ret = of_overlay_fdt_apply(info->dtb_begin, size, &info->overlay_id);
	if (overlay_id)
		*overlay_id = info->overlay_id;
	if (ret < 0)
		goto out;
2275

2276
	pr_debug("%s applied\n", overlay_name);
2277 2278

out:
2279 2280 2281 2282
	if (ret != info->expected_result)
		pr_err("of_overlay_fdt_apply() expected %d, ret=%d, %s\n",
		       info->expected_result, ret, overlay_name);

2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311
	return (ret == info->expected_result);
}

/*
 * The purpose of of_unittest_overlay_high_level is to add an overlay
 * in the normal fashion.  This is a test of the whole picture,
 * instead of individual elements.
 *
 * The first part of the function is _not_ normal overlay usage; it is
 * finishing splicing the base overlay device tree into the live tree.
 */
static __init void of_unittest_overlay_high_level(void)
{
	struct device_node *last_sibling;
	struct device_node *np;
	struct device_node *of_symbols;
	struct device_node *overlay_base_symbols;
	struct device_node **pprev;
	struct property *prop;

	if (!overlay_base_root) {
		unittest(0, "overlay_base_root not initialized\n");
		return;
	}

	/*
	 * Could not fixup phandles in unittest_unflatten_overlay_base()
	 * because kmalloc() was not yet available.
	 */
2312
	of_overlay_mutex_lock();
2313
	of_resolve_phandles(overlay_base_root);
2314 2315
	of_overlay_mutex_unlock();

2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370

	/*
	 * do not allow overlay_base to duplicate any node already in
	 * tree, this greatly simplifies the code
	 */

	/*
	 * remove overlay_base_root node "__local_fixups", after
	 * being used by of_resolve_phandles()
	 */
	pprev = &overlay_base_root->child;
	for (np = overlay_base_root->child; np; np = np->sibling) {
		if (!of_node_cmp(np->name, "__local_fixups__")) {
			*pprev = np->sibling;
			break;
		}
		pprev = &np->sibling;
	}

	/* remove overlay_base_root node "__symbols__" if in live tree */
	of_symbols = of_get_child_by_name(of_root, "__symbols__");
	if (of_symbols) {
		/* will have to graft properties from node into live tree */
		pprev = &overlay_base_root->child;
		for (np = overlay_base_root->child; np; np = np->sibling) {
			if (!of_node_cmp(np->name, "__symbols__")) {
				overlay_base_symbols = np;
				*pprev = np->sibling;
				break;
			}
			pprev = &np->sibling;
		}
	}

	for (np = overlay_base_root->child; np; np = np->sibling) {
		if (of_get_child_by_name(of_root, np->name)) {
			unittest(0, "illegal node name in overlay_base %s",
				np->name);
			return;
		}
	}

	/*
	 * overlay 'overlay_base' is not allowed to have root
	 * properties, so only need to splice nodes into main device tree.
	 *
	 * root node of *overlay_base_root will not be freed, it is lost
	 * memory.
	 */

	for (np = overlay_base_root->child; np; np = np->sibling)
		np->parent = of_root;

	mutex_lock(&of_mutex);

2371
	for (last_sibling = np = of_root->child; np; np = np->sibling)
2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
		last_sibling = np;

	if (last_sibling)
		last_sibling->sibling = overlay_base_root->child;
	else
		of_root->child = overlay_base_root->child;

	for_each_of_allnodes_from(overlay_base_root, np)
		__of_attach_node_sysfs(np);

	if (of_symbols) {
2383
		struct property *new_prop;
2384
		for_each_property_of_node(overlay_base_symbols, prop) {
2385 2386 2387 2388 2389 2390 2391

			new_prop = __of_prop_dup(prop, GFP_KERNEL);
			if (!new_prop) {
				unittest(0, "__of_prop_dup() of '%s' from overlay_base node __symbols__",
					 prop->name);
				goto err_unlock;
			}
2392 2393 2394
			if (__of_add_property(of_symbols, new_prop)) {
				/* "name" auto-generated by unflatten */
				if (!strcmp(new_prop->name, "name"))
2395 2396
					continue;
				unittest(0, "duplicate property '%s' in overlay_base node __symbols__",
2397
					 prop->name);
2398
				goto err_unlock;
2399
			}
2400
			if (__of_add_property_sysfs(of_symbols, new_prop)) {
2401
				unittest(0, "unable to add property '%s' in overlay_base node __symbols__ to sysfs",
2402
					 prop->name);
2403
				goto err_unlock;
2404 2405 2406 2407 2408 2409 2410 2411 2412
			}
		}
	}

	mutex_unlock(&of_mutex);


	/* now do the normal overlay usage test */

2413
	unittest(overlay_data_apply("overlay", NULL),
2414 2415
		 "Adding overlay 'overlay' failed\n");

2416
	unittest(overlay_data_apply("overlay_bad_phandle", NULL),
2417
		 "Adding overlay 'overlay_bad_phandle' failed\n");
2418

2419
	unittest(overlay_data_apply("overlay_bad_symbol", NULL),
2420 2421
		 "Adding overlay 'overlay_bad_symbol' failed\n");

2422 2423 2424 2425
	return;

err_unlock:
	mutex_unlock(&of_mutex);
2426 2427 2428 2429 2430 2431 2432 2433
}

#else

static inline __init void of_unittest_overlay_high_level(void) {}

#endif

2434
static int __init of_unittest(void)
G
Grant Likely 已提交
2435 2436
{
	struct device_node *np;
2437 2438
	int res;

2439 2440
	/* adding data for unittest */
	res = unittest_data_add();
2441 2442
	if (res)
		return res;
2443 2444
	if (!of_aliases)
		of_aliases = of_find_node_by_path("/aliases");
G
Grant Likely 已提交
2445 2446 2447 2448 2449 2450 2451 2452

	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
	if (!np) {
		pr_info("No testcase data in device tree; not running tests\n");
		return 0;
	}
	of_node_put(np);

2453 2454 2455 2456 2457 2458
	pr_info("start of unittest - you will see error messages\n");
	of_unittest_check_tree_linkage();
	of_unittest_check_phandles();
	of_unittest_find_node_by_name();
	of_unittest_dynamic();
	of_unittest_parse_phandle_with_args();
2459
	of_unittest_parse_phandle_with_args_map();
2460
	of_unittest_printf();
2461 2462 2463 2464 2465 2466 2467 2468
	of_unittest_property_string();
	of_unittest_property_copy();
	of_unittest_changeset();
	of_unittest_parse_interrupts();
	of_unittest_parse_interrupts_extended();
	of_unittest_match_node();
	of_unittest_platform_populate();
	of_unittest_overlay();
2469

2470
	/* Double check linkage after removing testcase data */
2471
	of_unittest_check_tree_linkage();
2472

2473 2474
	of_unittest_overlay_high_level();

2475 2476
	pr_info("end of unittest - %i passed, %i failed\n",
		unittest_results.passed, unittest_results.failed);
2477

G
Grant Likely 已提交
2478 2479
	return 0;
}
2480
late_initcall(of_unittest);