drivers/of/unittest.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Self tests for device tree subsystem
   4  */
   5
   6 #define pr_fmt(fmt) "### dt-test ### " fmt
   7
   8 #include <linux/memblock.h>
   9 #include <linux/clk.h>
  10 #include <linux/dma-direct.h> /* to test phys_to_dma/dma_to_phys */
  11 #include <linux/err.h>
  12 #include <linux/errno.h>
  13 #include <linux/hashtable.h>
  14 #include <linux/libfdt.h>
  15 #include <linux/of.h>
  16 #include <linux/of_address.h>
  17 #include <linux/of_fdt.h>
  18 #include <linux/of_irq.h>
  19 #include <linux/of_platform.h>
  20 #include <linux/list.h>
  21 #include <linux/mutex.h>
  22 #include <linux/slab.h>
  23 #include <linux/device.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/pci.h>
  26 #include <linux/kernel.h>
  27
  28 #include <linux/i2c.h>
  29 #include <linux/i2c-mux.h>
  30 #include <linux/gpio/driver.h>
  31
  32 #include <linux/bitops.h>
  33
  34 #include "of_private.h"
  35
  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("/testcase-data");
  86         name = kasprintf(GFP_KERNEL, "%pOF", np);
  87         unittest(np && name && !strcmp("/testcase-data", name),
  88                 "find /testcase-data failed\n");
  89         of_node_put(np);
  90         kfree(name);
  91
  92         /* Test if trailing '/' works */
  93         np = of_find_node_by_path("/testcase-data/");
  94         unittest(!np, "trailing '/' on /testcase-data/ should fail\n");
  95
  96         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
  97         name = kasprintf(GFP_KERNEL, "%pOF", np);
  98         unittest(np && name && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
  99                 "find /testcase-data/phandle-tests/consumer-a failed\n");
 100         of_node_put(np);
 101         kfree(name);
 102
 103         np = of_find_node_by_path("testcase-alias");
 104         name = kasprintf(GFP_KERNEL, "%pOF", np);
 105         unittest(np && name && !strcmp("/testcase-data", name),
 106                 "find testcase-alias failed\n");
 107         of_node_put(np);
 108         kfree(name);
 109
 110         /* Test if trailing '/' works on aliases */
 111         np = of_find_node_by_path("testcase-alias/");
 112         unittest(!np, "trailing '/' on testcase-alias/ should fail\n");
 113
 114         np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
 115         name = kasprintf(GFP_KERNEL, "%pOF", np);
 116         unittest(np && name && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
 117                 "find testcase-alias/phandle-tests/consumer-a failed\n");
 118         of_node_put(np);
 119         kfree(name);
 120
 121         np = of_find_node_by_path("/testcase-data/missing-path");
 122         unittest(!np, "non-existent path returned node %pOF\n", np);
 123         of_node_put(np);
 124
 125         np = of_find_node_by_path("missing-alias");
 126         unittest(!np, "non-existent alias returned node %pOF\n", np);
 127         of_node_put(np);
 128
 129         np = of_find_node_by_path("testcase-alias/missing-path");
 130         unittest(!np, "non-existent alias with relative path returned node %pOF\n", np);
 131         of_node_put(np);
 132
 133         np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
 134         unittest(np && !strcmp("testoption", options),
 135                  "option path test failed\n");
 136         of_node_put(np);
 137
 138         np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
 139         unittest(np && !strcmp("test/option", options),
 140                  "option path test, subcase #1 failed\n");
 141         of_node_put(np);
 142
 143         np = of_find_node_opts_by_path("/testcase-data/testcase-device1:test/option", &options);
 144         unittest(np && !strcmp("test/option", options),
 145                  "option path test, subcase #2 failed\n");
 146         of_node_put(np);
 147
 148         np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
 149         unittest(np, "NULL option path test failed\n");
 150         of_node_put(np);
 151
 152         np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
 153                                        &options);
 154         unittest(np && !strcmp("testaliasoption", options),
 155                  "option alias path test failed\n");
 156         of_node_put(np);
 157
 158         np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
 159                                        &options);
 160         unittest(np && !strcmp("test/alias/option", options),
 161                  "option alias path test, subcase #1 failed\n");
 162         of_node_put(np);
 163
 164         np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
 165         unittest(np, "NULL option alias path test failed\n");
 166         of_node_put(np);
 167
 168         options = "testoption";
 169         np = of_find_node_opts_by_path("testcase-alias", &options);
 170         unittest(np && !options, "option clearing test failed\n");
 171         of_node_put(np);
 172
 173         options = "testoption";
 174         np = of_find_node_opts_by_path("/", &options);
 175         unittest(np && !options, "option clearing root node test failed\n");
 176         of_node_put(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("/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(4, 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(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(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(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(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, 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+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(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(full_name);
 320         if (!np) {
 321                 unittest(np, "testcase data missing\n");
 322                 return;
 323         }
 324
 325         num_to_str(phandle_str, sizeof(phandle_str), np->phandle, 0);
 326
 327         of_unittest_printf_one(np, "%pOF",  full_name);
 328         of_unittest_printf_one(np, "%pOFf", full_name);
 329         of_unittest_printf_one(np, "%pOFn", "dev");
 330         of_unittest_printf_one(np, "%2pOFn", "dev");
 331         of_unittest_printf_one(np, "%5pOFn", "  dev");
 332         of_unittest_printf_one(np, "%pOFnc", "dev:test-sub-device");
 333         of_unittest_printf_one(np, "%pOFp", phandle_str);
 334         of_unittest_printf_one(np, "%pOFP", "dev@100");
 335         of_unittest_printf_one(np, "ABC %pOFP ABC", "ABC dev@100 ABC");
 336         of_unittest_printf_one(np, "%10pOFP", "   dev@100");
 337         of_unittest_printf_one(np, "%-10pOFP", "dev@100   ");
 338         of_unittest_printf_one(of_root, "%pOFP", "/");
 339         of_unittest_printf_one(np, "%pOFF", "----");
 340         of_unittest_printf_one(np, "%pOFPF", "dev@100:----");
 341         of_unittest_printf_one(np, "%pOFPFPc", "dev@100:----:dev@100:test-sub-device");
 342         of_unittest_printf_one(np, "%pOFc", "test-sub-device");
 343         of_unittest_printf_one(np, "%pOFC",
 344                         "\"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(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(&nh->node);
 387                 kfree(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("/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, "phandle-list", "#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, "phandle-list",
 411                                                 "#phandle-cells", i, &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(args.np);
 463         }
 464
 465         /* Check for missing list property */
 466         memset(&args, 0, sizeof(args));
 467         rc = of_parse_phandle_with_args(np, "phandle-list-missing",
 468                                         "#phandle-cells", 0, &args);
 469         unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 470         rc = of_count_phandle_with_args(np, "phandle-list-missing",
 471                                         "#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, "phandle-list",
 481                                         "#phandle-cells-missing", 0, &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, "phandle-list",
 492                                         "#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, "phandle-list-bad-phandle",
 506                                         "#phandle-cells", 0, &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, "phandle-list-bad-phandle",
 517                                         "#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, "phandle-list-bad-args",
 531                                         "#phandle-cells", 1, &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, "phandle-list-bad-args",
 542                                         "#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("/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("/testcase-data/phandle-tests/provider0");
 564         p[1] = of_find_node_by_path("/testcase-data/phandle-tests/provider1");
 565         p[2] = of_find_node_by_path("/testcase-data/phandle-tests/provider2");
 566         p[3] = of_find_node_by_path("/testcase-data/phandle-tests/provider3");
 567         p[4] = of_find_node_by_path("/testcase-data/phandle-tests/provider4");
 568         p[5] = of_find_node_by_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, "phandle-list", "#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, "phandle-list",
 585                                                     "phandle", i, &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(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, "phandle-list-missing",
 654                                             "phandle", 0, &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, "phandle-list",
 664                                             "phandle-missing", 0, &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, "phandle-list-bad-phandle",
 677                                             "phandle", 0, &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, "phandle-list-bad-args",
 690                                             "phandle", 1, &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(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("/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, "phandle-list-names", "first");
 717         unittest(rc == 0, "first expected:0 got:%i\n", rc);
 718         rc = of_property_match_string(np, "phandle-list-names", "second");
 719         unittest(rc == 1, "second expected:1 got:%i\n", rc);
 720         rc = of_property_match_string(np, "phandle-list-names", "third");
 721         unittest(rc == 2, "third expected:2 got:%i\n", rc);
 722         rc = of_property_match_string(np, "phandle-list-names", "fourth");
 723         unittest(rc == -ENODATA, "unmatched string; rc=%i\n", rc);
 724         rc = of_property_match_string(np, "missing-property", "blah");
 725         unittest(rc == -EINVAL, "missing property; rc=%i\n", rc);
 726         rc = of_property_match_string(np, "empty-property", "blah");
 727         unittest(rc == -ENODATA, "empty property; rc=%i\n", rc);
 728         rc = of_property_match_string(np, "unterminated-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, "string-property");
 733         unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 734         rc = of_property_count_strings(np, "phandle-list-names");
 735         unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 736         rc = of_property_count_strings(np, "unterminated-string");
 737         unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 738         rc = of_property_count_strings(np, "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, "string-property", 0, 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, "string-property", 1, 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, "phandle-list-names", 0, 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, "phandle-list-names", 1, 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, "phandle-list-names", 2, 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, "phandle-list-names", 3, 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, "unterminated-string", 0, 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, "unterminated-string-list", 0, 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, "unterminated-string-list", 2, 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, "string-property", strings, 4);
 768         unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 769         rc = of_property_read_string_array(np, "phandle-list-names", strings, 4);
 770         unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 771         rc = of_property_read_string_array(np, "unterminated-string", strings, 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, "unterminated-string-list", strings, 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, "unterminated-string-list", strings, 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, "phandle-list-names", strings, 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(&p1, GFP_KERNEL);
 797         unittest(new && propcmp(&p1, new), "empty property didn't copy correctly\n");
 798         kfree(new->value);
 799         kfree(new->name);
 800         kfree(new);
 801
 802         new = __of_prop_dup(&p2, GFP_KERNEL);
 803         unittest(new && propcmp(&p2, new), "non-empty property didn't copy correctly\n");
 804         kfree(new->value);
 805         kfree(new->name);
 806         kfree(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, "n1");
 827         unittest(n1, "testcase setup failure\n");
 828
 829         n2 = __of_node_dup(NULL, "n2");
 830         unittest(n2, "testcase setup failure\n");
 831
 832         n21 = __of_node_dup(NULL, "n21");
 833         unittest(n21, "testcase setup failure %p\n", n21);
 834
 835         nchangeset = of_find_node_by_path("/testcase-data/changeset");
 836         nremove = of_get_child_by_name(nchangeset, "node-remove");
 837         unittest(nremove, "testcase setup failure\n");
 838
 839         ppadd = __of_prop_dup(&padd, GFP_KERNEL);
 840         unittest(ppadd, "testcase setup failure\n");
 841
 842         ppname_n1  = __of_prop_dup(&pname_n1, GFP_KERNEL);
 843         unittest(ppname_n1, "testcase setup failure\n");
 844
 845         ppname_n2  = __of_prop_dup(&pname_n2, GFP_KERNEL);
 846         unittest(ppname_n2, "testcase setup failure\n");
 847
 848         ppname_n21 = __of_prop_dup(&pname_n21, GFP_KERNEL);
 849         unittest(ppname_n21, "testcase setup failure\n");
 850
 851         ppupdate = __of_prop_dup(&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(parent, "prop-remove", NULL);
 860         unittest(ppremove, "failed to find removal prop");
 861
 862         of_changeset_init(&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(&chgset, n2, "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(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(np);
 898         unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n22")),
 899                  "'%pOF' not added\n", n22);
 900         of_node_put(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(parent, "prop-remove", NULL);
 908         unittest(ppremove, "failed to find removed prop after revert\n");
 909
 910         ret = of_property_read_string(parent, "prop-update", &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(&chgset);
 916
 917         of_node_put(n1);
 918         of_node_put(n2);
 919         of_node_put(n21);
 920         of_node_put(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("/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);
 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(sizeof(struct device), GFP_KERNEL);
 968                 if (!dev_bogus) {
 969                         unittest(0, "kzalloc() failed\n");
 970                         kfree(map);
 971                         return;
 972                 }
 973
 974                 dev_bogus->dma_range_map = map;
 975                 paddr = dma_to_phys(dev_bogus, expect_dma_addr);
 976                 dma_addr = phys_to_dma(dev_bogus, 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(map);
 986                 kfree(dev_bogus);
 987         }
 988         of_node_put(np);
 989 #endif
 990 }
 991
 992 static void __init of_unittest_parse_dma_ranges(void)
 993 {
 994         of_unittest_dma_ranges_one("/testcase-data/address-tests/device@70000000",
 995                 0x0, 0x20000000);
 996         if (IS_ENABLED(CONFIG_ARCH_DMA_ADDR_T_64BIT))
 997                 of_unittest_dma_ranges_one("/testcase-data/address-tests/bus@80000000/device@1000",
 998                         0x100000000, 0x20000000);
 999         of_unittest_dma_ranges_one("/testcase-data/address-tests/pci@90000000",
1000                 0x80000000, 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("/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, 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(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("/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, np)) {
1070                 pr_err("missing ranges property\n");
1071                 return;
1072         }
1073
1074         ret = of_range_to_resource(np, 1, &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);
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(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("/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, 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(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("/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, 0, &addr, &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(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(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(np, expected->index, &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(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("/testcase-data/address-tests2/bus-2cell@10000000/device@100000",
1266                                of_unittest_reg_2cell_expected_res,
1267                                ARRAY_SIZE(of_unittest_reg_2cell_expected_res));
1268
1269         of_unittest_check_addr("/testcase-data/address-tests2/bus-3cell@20000000/local-bus@100000/device@f1001000",
1270                                of_unittest_reg_3cell_expected_res,
1271                                ARRAY_SIZE(of_unittest_reg_3cell_expected_res));
1272
1273         of_unittest_check_addr("/testcase-data/address-tests2/pcie@d1070000/pci@0,0/dev@0,0/local-bus@0/dev@e0000000",
1274                                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("/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(np, i, &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(np);
1307
1308         np = of_find_node_by_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(np, i, &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(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("/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(np, i, &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(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(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(match_node_table, 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("/testcase-data");
1516         of_platform_default_populate(np, NULL, NULL);
1517
1518         /* Test that a missing irq domain returns -EPROBE_DEFER */
1519         np = of_find_node_by_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("/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("/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(&test_bus_info);
1551         rc = PTR_ERR_OR_ZERO(test_bus);
1552         unittest(!rc, "testbus registration failed; rc=%i\n", rc);
1553         if (rc) {
1554                 of_node_put(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(test_bus, &test_bus_res, 1);
1567
1568         of_platform_populate(np, match, NULL, &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(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(&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(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(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, "%pOF", np);
1656         if (!full_name)
1657                 return;
1658
1659         if (!strcmp(full_name, "/__local_fixups__") ||
1660             !strcmp(full_name, "/__fixups__")) {
1661                 kfree(full_name);
1662                 return;
1663         }
1664
1665         dup = of_find_node_by_path(full_name);
1666         kfree(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(np, OF_DETACHED);
1680         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1681
1682         __of_attach_node_sysfs(np);
1683         mutex_unlock(&of_mutex);
1684
1685         while (child) {
1686                 next = child->sibling;
1687                 attach_node_and_children(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 + 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(unittest_data_align, NULL, &unittest_data_node);
1725         if (!ret) {
1726                 pr_warn("%s: unflatten testcases tree failed\n", __func__);
1727                 kfree(unittest_data);
1728                 return -ENODATA;
1729         }
1730         if (!unittest_data_node) {
1731                 pr_warn("%s: testcases tree is empty\n", __func__);
1732                 kfree(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(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(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(np, NULL, NULL, &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(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(sizeof(*devptr), GFP_KERNEL);
1872         if (!devptr)
1873                 return -ENOMEM;
1874
1875         platform_set_drvdata(pdev, 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(&devptr->chip);
1902
1903         kfree(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(np);
2066         of_node_put(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(&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, sizeof(buf) - 1, "%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(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, sizeof(buf) - 1,
2146                 "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);
2192                 if (ret == -ENODEV) {
2193                         overlay_name = overlay_name_from_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(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(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, 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);
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);
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(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(0, 0, 0, 1, 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(1, 1, 1, 0, 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(2, 2, 0, 1, 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(3, 3, 1, 0, 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(4, 4, 0, 1, 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(5, 5, 0, 1, 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 + i, 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(overlay_nr + 0);
2444
2445         ret = overlay_data_apply(overlay_name, &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 + 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(overlay_nr + 1);
2461
2462         ret = overlay_data_apply(overlay_name, &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 + 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 + i, 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)) {
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(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 + i, 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(overlay_nr + 0);
2531
2532         ret = overlay_data_apply(overlay_name, &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 + 0);
2544
2545         overlay_name = overlay_name_from_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);
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 + 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);
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)) {
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(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(10, 10, 0, 1, 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, "%s/test-unittest101",
2623                         unittest_path(10, PDEV_OVERLAY));
2624         if (unittest(child_path, "overlay test %d failed; kasprintf\n", 10))
2625                 return;
2626
2627         ret = of_path_device_type_exists(child_path, PDEV_OVERLAY);
2628         kfree(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(11, 11, 0, 1,
2640                         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, sizeof(*std), GFP_KERNEL);
2689         if (!std)
2690                 return -ENOMEM;
2691
2692         /* link them together */
2693         std->pdev = pdev;
2694         platform_set_drvdata(pdev, std);
2695
2696         adap = &std->adap;
2697         i2c_set_adapdata(adap, 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(&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(child, "reg", &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(adap, dev, nchans, 0, 0,
2814                              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, 0, i, 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, 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(&unittest_i2c_mux_driver);
2893 #endif
2894         platform_driver_unregister(&unittest_i2c_bus_driver);
2895         i2c_del_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(12, 12, 0, 1, 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(13, 13, 1, 0, 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(15, 15, 0, 1, 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(nd->overlay);
2989
2990         switch (action) {
2991
2992         case OF_OVERLAY_PRE_APPLY:
2993                 found = of_find_node_by_name(nd->overlay, "test-unittest16");
2994                 if (found) {
2995                         of_node_put(found);
2996                         ret = -EBUSY;
2997                 }
2998                 break;
2999
3000         case OF_OVERLAY_POST_APPLY:
3001                 found = of_find_node_by_name(nd->overlay, "test-unittest17");
3002                 if (found) {
3003                         of_node_put(found);
3004                         ret = -EEXIST;
3005                 }
3006                 break;
3007
3008         case OF_OVERLAY_PRE_REMOVE:
3009                 found = of_find_node_by_name(nd->overlay, "test-unittest18");
3010                 if (found) {
3011                         of_node_put(found);
3012                         ret = -EXDEV;
3013                 }
3014                 break;
3015
3016         case OF_OVERLAY_POST_REMOVE:
3017                 found = of_find_node_by_name(nd->overlay, "test-unittest19");
3018                 if (found) {
3019                         of_node_put(found);
3020                         ret = -ENODEV;
3021                 }
3022                 break;
3023
3024         default:                        /* should not happen */
3025                 of_node_put(nd->overlay);
3026                 ret = -EINVAL;
3027                 break;
3028         }
3029
3030         if (ret)
3031                 return notifier_from_errno(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(&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);
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);
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);
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(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(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(100, 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(101, 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(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(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(&np->kobj.kref);
3261                 if (refcount == 1)
3262                         found_refcount_one = 1;
3263                 else
3264                         of_node_put(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(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(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(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(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(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("%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(new_fdt, NULL, &overlay_base_root,
3541                                 dt_alloc_memory, 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(info->dtbo_begin, size, &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(&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(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, "__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(of_root, "__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, "__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(np);
3680                                 of_node_put(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(of_symbols, new_prop)) {
3721                                 kfree(new_prop->name);
3722                                 kfree(new_prop->value);
3723                                 kfree(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(of_symbols, 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(&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", 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(&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(info->dtbo_begin, size, &ovcs_id, dn);
3922         of_node_put(dn);
3923         if (ret)
3924                 return ret;
3925
3926         of_platform_default_populate(dn, NULL, &pdev->dev);
3927         pci_set_drvdata(pdev, (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(&pdev->dev);
3937         of_overlay_remove(&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, "%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(np, "reg", NULL);
4010                 unittest(reg, "Failed to get reg property\n");
4011                 if (!reg)
4012                         rc = -ENODEV;
4013         } else {
4014                 path = kasprintf(GFP_KERNEL, "%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(&pdev->dev);
4018                 unittest(!child_dev, "Child device is not removed\n");
4019         }
4020
4021 failed:
4022         kfree(path);
4023         if (np)
4024                 of_node_put(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(&testdrv_driver);
4045                 return;
4046         }
4047
4048         while ((pdev = pci_get_device(PCI_VENDOR_ID_REDHAT, 0x5, pdev)) != NULL) {
4049                 of_unittest_pci_node_verify(pdev, true);
4050                 of_unittest_pci_dev_num++;
4051         }
4052         if (pdev)
4053                 pci_dev_put(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(&testdrv_driver);
4063
4064         while ((pdev = pci_get_device(PCI_VENDOR_ID_REDHAT, 0x5, pdev)) != NULL)
4065                 of_unittest_pci_node_verify(pdev, false);
4066         if (pdev)
4067                 pci_dev_put(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("/aliases");
4092
4093         np = of_find_node_by_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(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);