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