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