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/bootmem.h>
   9 #include <linux/clk.h>
  10 #include <linux/err.h>
  11 #include <linux/errno.h>
  12 #include <linux/hashtable.h>
  13 #include <linux/libfdt.h>
  14 #include <linux/of.h>
  15 #include <linux/of_fdt.h>
  16 #include <linux/of_irq.h>
  17 #include <linux/of_platform.h>
  18 #include <linux/list.h>
  19 #include <linux/mutex.h>
  20 #include <linux/slab.h>
  21 #include <linux/device.h>
  22 #include <linux/platform_device.h>
  23
  24 #include <linux/i2c.h>
  25 #include <linux/i2c-mux.h>
  26
  27 #include <linux/bitops.h>
  28
  29 #include "of_private.h"
  30
  31 static struct unittest_results {
  32         int passed;
  33         int failed;
  34 } unittest_results;
  35
  36 #define unittest(result, fmt, ...) ({ \
  37         bool failed = !(result); \
  38         if (failed) { \
  39                 unittest_results.failed++; \
  40                 pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
  41         } else { \
  42                 unittest_results.passed++; \
  43                 pr_debug("pass %s():%i\n", __func__, __LINE__); \
  44         } \
  45         failed; \
  46 })
  47
  48 static void __init of_unittest_find_node_by_name(void)
  49 {
  50         struct device_node *np;
  51         const char *options, *name;
  52
  53         np = of_find_node_by_path("/testcase-data");
  54         name = kasprintf(GFP_KERNEL, "%pOF", np);
  55         unittest(np && !strcmp("/testcase-data", name),
  56                 "find /testcase-data failed\n");
  57         of_node_put(np);
  58         kfree(name);
  59
  60         /* Test if trailing '/' works */
  61         np = of_find_node_by_path("/testcase-data/");
  62         unittest(!np, "trailing '/' on /testcase-data/ should fail\n");
  63
  64         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
  65         name = kasprintf(GFP_KERNEL, "%pOF", np);
  66         unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
  67                 "find /testcase-data/phandle-tests/consumer-a failed\n");
  68         of_node_put(np);
  69         kfree(name);
  70
  71         np = of_find_node_by_path("testcase-alias");
  72         name = kasprintf(GFP_KERNEL, "%pOF", np);
  73         unittest(np && !strcmp("/testcase-data", name),
  74                 "find testcase-alias failed\n");
  75         of_node_put(np);
  76         kfree(name);
  77
  78         /* Test if trailing '/' works on aliases */
  79         np = of_find_node_by_path("testcase-alias/");
  80         unittest(!np, "trailing '/' on testcase-alias/ should fail\n");
  81
  82         np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
  83         name = kasprintf(GFP_KERNEL, "%pOF", np);
  84         unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
  85                 "find testcase-alias/phandle-tests/consumer-a failed\n");
  86         of_node_put(np);
  87         kfree(name);
  88
  89         np = of_find_node_by_path("/testcase-data/missing-path");
  90         unittest(!np, "non-existent path returned node %pOF\n", np);
  91         of_node_put(np);
  92
  93         np = of_find_node_by_path("missing-alias");
  94         unittest(!np, "non-existent alias returned node %pOF\n", np);
  95         of_node_put(np);
  96
  97         np = of_find_node_by_path("testcase-alias/missing-path");
  98         unittest(!np, "non-existent alias with relative path returned node %pOF\n", np);
  99         of_node_put(np);
 100
 101         np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
 102         unittest(np && !strcmp("testoption", options),
 103                  "option path test failed\n");
 104         of_node_put(np);
 105
 106         np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
 107         unittest(np && !strcmp("test/option", options),
 108                  "option path test, subcase #1 failed\n");
 109         of_node_put(np);
 110
 111         np = of_find_node_opts_by_path("/testcase-data/testcase-device1:test/option", &options);
 112         unittest(np && !strcmp("test/option", options),
 113                  "option path test, subcase #2 failed\n");
 114         of_node_put(np);
 115
 116         np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
 117         unittest(np, "NULL option path test failed\n");
 118         of_node_put(np);
 119
 120         np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
 121                                        &options);
 122         unittest(np && !strcmp("testaliasoption", options),
 123                  "option alias path test failed\n");
 124         of_node_put(np);
 125
 126         np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
 127                                        &options);
 128         unittest(np && !strcmp("test/alias/option", options),
 129                  "option alias path test, subcase #1 failed\n");
 130         of_node_put(np);
 131
 132         np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
 133         unittest(np, "NULL option alias path test failed\n");
 134         of_node_put(np);
 135
 136         options = "testoption";
 137         np = of_find_node_opts_by_path("testcase-alias", &options);
 138         unittest(np && !options, "option clearing test failed\n");
 139         of_node_put(np);
 140
 141         options = "testoption";
 142         np = of_find_node_opts_by_path("/", &options);
 143         unittest(np && !options, "option clearing root node test failed\n");
 144         of_node_put(np);
 145 }
 146
 147 static void __init of_unittest_dynamic(void)
 148 {
 149         struct device_node *np;
 150         struct property *prop;
 151
 152         np = of_find_node_by_path("/testcase-data");
 153         if (!np) {
 154                 pr_err("missing testcase data\n");
 155                 return;
 156         }
 157
 158         /* Array of 4 properties for the purpose of testing */
 159         prop = kzalloc(sizeof(*prop) * 4, GFP_KERNEL);
 160         if (!prop) {
 161                 unittest(0, "kzalloc() failed\n");
 162                 return;
 163         }
 164
 165         /* Add a new property - should pass*/
 166         prop->name = "new-property";
 167         prop->value = "new-property-data";
 168         prop->length = strlen(prop->value);
 169         unittest(of_add_property(np, prop) == 0, "Adding a new property failed\n");
 170
 171         /* Try to add an existing property - should fail */
 172         prop++;
 173         prop->name = "new-property";
 174         prop->value = "new-property-data-should-fail";
 175         prop->length = strlen(prop->value);
 176         unittest(of_add_property(np, prop) != 0,
 177                  "Adding an existing property should have failed\n");
 178
 179         /* Try to modify an existing property - should pass */
 180         prop->value = "modify-property-data-should-pass";
 181         prop->length = strlen(prop->value);
 182         unittest(of_update_property(np, prop) == 0,
 183                  "Updating an existing property should have passed\n");
 184
 185         /* Try to modify non-existent property - should pass*/
 186         prop++;
 187         prop->name = "modify-property";
 188         prop->value = "modify-missing-property-data-should-pass";
 189         prop->length = strlen(prop->value);
 190         unittest(of_update_property(np, prop) == 0,
 191                  "Updating a missing property should have passed\n");
 192
 193         /* Remove property - should pass */
 194         unittest(of_remove_property(np, prop) == 0,
 195                  "Removing a property should have passed\n");
 196
 197         /* Adding very large property - should pass */
 198         prop++;
 199         prop->name = "large-property-PAGE_SIZEx8";
 200         prop->length = PAGE_SIZE * 8;
 201         prop->value = kzalloc(prop->length, GFP_KERNEL);
 202         unittest(prop->value != NULL, "Unable to allocate large buffer\n");
 203         if (prop->value)
 204                 unittest(of_add_property(np, prop) == 0,
 205                          "Adding a large property should have passed\n");
 206 }
 207
 208 static int __init of_unittest_check_node_linkage(struct device_node *np)
 209 {
 210         struct device_node *child;
 211         int count = 0, rc;
 212
 213         for_each_child_of_node(np, child) {
 214                 if (child->parent != np) {
 215                         pr_err("Child node %s links to wrong parent %s\n",
 216                                  child->name, np->name);
 217                         rc = -EINVAL;
 218                         goto put_child;
 219                 }
 220
 221                 rc = of_unittest_check_node_linkage(child);
 222                 if (rc < 0)
 223                         goto put_child;
 224                 count += rc;
 225         }
 226
 227         return count + 1;
 228 put_child:
 229         of_node_put(child);
 230         return rc;
 231 }
 232
 233 static void __init of_unittest_check_tree_linkage(void)
 234 {
 235         struct device_node *np;
 236         int allnode_count = 0, child_count;
 237
 238         if (!of_root)
 239                 return;
 240
 241         for_each_of_allnodes(np)
 242                 allnode_count++;
 243         child_count = of_unittest_check_node_linkage(of_root);
 244
 245         unittest(child_count > 0, "Device node data structure is corrupted\n");
 246         unittest(child_count == allnode_count,
 247                  "allnodes list size (%i) doesn't match sibling lists size (%i)\n",
 248                  allnode_count, child_count);
 249         pr_debug("allnodes list size (%i); sibling lists size (%i)\n", allnode_count, child_count);
 250 }
 251
 252 static void __init of_unittest_printf_one(struct device_node *np, const char *fmt,
 253                                           const char *expected)
 254 {
 255         unsigned char buf[strlen(expected)+10];
 256         int size, i;
 257
 258         /* Baseline; check conversion with a large size limit */
 259         memset(buf, 0xff, sizeof(buf));
 260         size = snprintf(buf, sizeof(buf) - 2, fmt, np);
 261
 262         /* use strcmp() instead of strncmp() here to be absolutely sure strings match */
 263         unittest((strcmp(buf, expected) == 0) && (buf[size+1] == 0xff),
 264                 "sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
 265                 fmt, expected, buf);
 266
 267         /* Make sure length limits work */
 268         size++;
 269         for (i = 0; i < 2; i++, size--) {
 270                 /* Clear the buffer, and make sure it works correctly still */
 271                 memset(buf, 0xff, sizeof(buf));
 272                 snprintf(buf, size+1, fmt, np);
 273                 unittest(strncmp(buf, expected, size) == 0 && (buf[size+1] == 0xff),
 274                         "snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
 275                         size, fmt, expected, buf);
 276         }
 277 }
 278
 279 static void __init of_unittest_printf(void)
 280 {
 281         struct device_node *np;
 282         const char *full_name = "/testcase-data/platform-tests/test-device@1/dev@100";
 283         char phandle_str[16] = "";
 284
 285         np = of_find_node_by_path(full_name);
 286         if (!np) {
 287                 unittest(np, "testcase data missing\n");
 288                 return;
 289         }
 290
 291         num_to_str(phandle_str, sizeof(phandle_str), np->phandle);
 292
 293         of_unittest_printf_one(np, "%pOF",  full_name);
 294         of_unittest_printf_one(np, "%pOFf", full_name);
 295         of_unittest_printf_one(np, "%pOFp", phandle_str);
 296         of_unittest_printf_one(np, "%pOFP", "dev@100");
 297         of_unittest_printf_one(np, "ABC %pOFP ABC", "ABC dev@100 ABC");
 298         of_unittest_printf_one(np, "%10pOFP", "   dev@100");
 299         of_unittest_printf_one(np, "%-10pOFP", "dev@100   ");
 300         of_unittest_printf_one(of_root, "%pOFP", "/");
 301         of_unittest_printf_one(np, "%pOFF", "----");
 302         of_unittest_printf_one(np, "%pOFPF", "dev@100:----");
 303         of_unittest_printf_one(np, "%pOFPFPc", "dev@100:----:dev@100:test-sub-device");
 304         of_unittest_printf_one(np, "%pOFc", "test-sub-device");
 305         of_unittest_printf_one(np, "%pOFC",
 306                         "\"test-sub-device\",\"test-compat2\",\"test-compat3\"");
 307 }
 308
 309 struct node_hash {
 310         struct hlist_node node;
 311         struct device_node *np;
 312 };
 313
 314 static DEFINE_HASHTABLE(phandle_ht, 8);
 315 static void __init of_unittest_check_phandles(void)
 316 {
 317         struct device_node *np;
 318         struct node_hash *nh;
 319         struct hlist_node *tmp;
 320         int i, dup_count = 0, phandle_count = 0;
 321
 322         for_each_of_allnodes(np) {
 323                 if (!np->phandle)
 324                         continue;
 325
 326                 hash_for_each_possible(phandle_ht, nh, node, np->phandle) {
 327                         if (nh->np->phandle == np->phandle) {
 328                                 pr_info("Duplicate phandle! %i used by %pOF and %pOF\n",
 329                                         np->phandle, nh->np, np);
 330                                 dup_count++;
 331                                 break;
 332                         }
 333                 }
 334
 335                 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
 336                 if (WARN_ON(!nh))
 337                         return;
 338
 339                 nh->np = np;
 340                 hash_add(phandle_ht, &nh->node, np->phandle);
 341                 phandle_count++;
 342         }
 343         unittest(dup_count == 0, "Found %i duplicates in %i phandles\n",
 344                  dup_count, phandle_count);
 345
 346         /* Clean up */
 347         hash_for_each_safe(phandle_ht, i, tmp, nh, node) {
 348                 hash_del(&nh->node);
 349                 kfree(nh);
 350         }
 351 }
 352
 353 static void __init of_unittest_parse_phandle_with_args(void)
 354 {
 355         struct device_node *np;
 356         struct of_phandle_args args;
 357         int i, rc;
 358
 359         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
 360         if (!np) {
 361                 pr_err("missing testcase data\n");
 362                 return;
 363         }
 364
 365         rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
 366         unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
 367
 368         for (i = 0; i < 8; i++) {
 369                 bool passed = true;
 370
 371                 rc = of_parse_phandle_with_args(np, "phandle-list",
 372                                                 "#phandle-cells", i, &args);
 373
 374                 /* Test the values from tests-phandle.dtsi */
 375                 switch (i) {
 376                 case 0:
 377                         passed &= !rc;
 378                         passed &= (args.args_count == 1);
 379                         passed &= (args.args[0] == (i + 1));
 380                         break;
 381                 case 1:
 382                         passed &= !rc;
 383                         passed &= (args.args_count == 2);
 384                         passed &= (args.args[0] == (i + 1));
 385                         passed &= (args.args[1] == 0);
 386                         break;
 387                 case 2:
 388                         passed &= (rc == -ENOENT);
 389                         break;
 390                 case 3:
 391                         passed &= !rc;
 392                         passed &= (args.args_count == 3);
 393                         passed &= (args.args[0] == (i + 1));
 394                         passed &= (args.args[1] == 4);
 395                         passed &= (args.args[2] == 3);
 396                         break;
 397                 case 4:
 398                         passed &= !rc;
 399                         passed &= (args.args_count == 2);
 400                         passed &= (args.args[0] == (i + 1));
 401                         passed &= (args.args[1] == 100);
 402                         break;
 403                 case 5:
 404                         passed &= !rc;
 405                         passed &= (args.args_count == 0);
 406                         break;
 407                 case 6:
 408                         passed &= !rc;
 409                         passed &= (args.args_count == 1);
 410                         passed &= (args.args[0] == (i + 1));
 411                         break;
 412                 case 7:
 413                         passed &= (rc == -ENOENT);
 414                         break;
 415                 default:
 416                         passed = false;
 417                 }
 418
 419                 unittest(passed, "index %i - data error on node %pOF rc=%i\n",
 420                          i, args.np, rc);
 421         }
 422
 423         /* Check for missing list property */
 424         rc = of_parse_phandle_with_args(np, "phandle-list-missing",
 425                                         "#phandle-cells", 0, &args);
 426         unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 427         rc = of_count_phandle_with_args(np, "phandle-list-missing",
 428                                         "#phandle-cells");
 429         unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
 430
 431         /* Check for missing cells property */
 432         rc = of_parse_phandle_with_args(np, "phandle-list",
 433                                         "#phandle-cells-missing", 0, &args);
 434         unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 435         rc = of_count_phandle_with_args(np, "phandle-list",
 436                                         "#phandle-cells-missing");
 437         unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 438
 439         /* Check for bad phandle in list */
 440         rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle",
 441                                         "#phandle-cells", 0, &args);
 442         unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 443         rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle",
 444                                         "#phandle-cells");
 445         unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 446
 447         /* Check for incorrectly formed argument list */
 448         rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
 449                                         "#phandle-cells", 1, &args);
 450         unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 451         rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
 452                                         "#phandle-cells");
 453         unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
 454 }
 455
 456 static void __init of_unittest_property_string(void)
 457 {
 458         const char *strings[4];
 459         struct device_node *np;
 460         int rc;
 461
 462         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
 463         if (!np) {
 464                 pr_err("No testcase data in device tree\n");
 465                 return;
 466         }
 467
 468         rc = of_property_match_string(np, "phandle-list-names", "first");
 469         unittest(rc == 0, "first expected:0 got:%i\n", rc);
 470         rc = of_property_match_string(np, "phandle-list-names", "second");
 471         unittest(rc == 1, "second expected:1 got:%i\n", rc);
 472         rc = of_property_match_string(np, "phandle-list-names", "third");
 473         unittest(rc == 2, "third expected:2 got:%i\n", rc);
 474         rc = of_property_match_string(np, "phandle-list-names", "fourth");
 475         unittest(rc == -ENODATA, "unmatched string; rc=%i\n", rc);
 476         rc = of_property_match_string(np, "missing-property", "blah");
 477         unittest(rc == -EINVAL, "missing property; rc=%i\n", rc);
 478         rc = of_property_match_string(np, "empty-property", "blah");
 479         unittest(rc == -ENODATA, "empty property; rc=%i\n", rc);
 480         rc = of_property_match_string(np, "unterminated-string", "blah");
 481         unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 482
 483         /* of_property_count_strings() tests */
 484         rc = of_property_count_strings(np, "string-property");
 485         unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 486         rc = of_property_count_strings(np, "phandle-list-names");
 487         unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 488         rc = of_property_count_strings(np, "unterminated-string");
 489         unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 490         rc = of_property_count_strings(np, "unterminated-string-list");
 491         unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
 492
 493         /* of_property_read_string_index() tests */
 494         rc = of_property_read_string_index(np, "string-property", 0, strings);
 495         unittest(rc == 0 && !strcmp(strings[0], "foobar"), "of_property_read_string_index() failure; rc=%i\n", rc);
 496         strings[0] = NULL;
 497         rc = of_property_read_string_index(np, "string-property", 1, strings);
 498         unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 499         rc = of_property_read_string_index(np, "phandle-list-names", 0, strings);
 500         unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
 501         rc = of_property_read_string_index(np, "phandle-list-names", 1, strings);
 502         unittest(rc == 0 && !strcmp(strings[0], "second"), "of_property_read_string_index() failure; rc=%i\n", rc);
 503         rc = of_property_read_string_index(np, "phandle-list-names", 2, strings);
 504         unittest(rc == 0 && !strcmp(strings[0], "third"), "of_property_read_string_index() failure; rc=%i\n", rc);
 505         strings[0] = NULL;
 506         rc = of_property_read_string_index(np, "phandle-list-names", 3, strings);
 507         unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 508         strings[0] = NULL;
 509         rc = of_property_read_string_index(np, "unterminated-string", 0, strings);
 510         unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 511         rc = of_property_read_string_index(np, "unterminated-string-list", 0, strings);
 512         unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
 513         strings[0] = NULL;
 514         rc = of_property_read_string_index(np, "unterminated-string-list", 2, strings); /* should fail */
 515         unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
 516         strings[1] = NULL;
 517
 518         /* of_property_read_string_array() tests */
 519         rc = of_property_read_string_array(np, "string-property", strings, 4);
 520         unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
 521         rc = of_property_read_string_array(np, "phandle-list-names", strings, 4);
 522         unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
 523         rc = of_property_read_string_array(np, "unterminated-string", strings, 4);
 524         unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
 525         /* -- An incorrectly formed string should cause a failure */
 526         rc = of_property_read_string_array(np, "unterminated-string-list", strings, 4);
 527         unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
 528         /* -- parsing the correctly formed strings should still work: */
 529         strings[2] = NULL;
 530         rc = of_property_read_string_array(np, "unterminated-string-list", strings, 2);
 531         unittest(rc == 2 && strings[2] == NULL, "of_property_read_string_array() failure; rc=%i\n", rc);
 532         strings[1] = NULL;
 533         rc = of_property_read_string_array(np, "phandle-list-names", strings, 1);
 534         unittest(rc == 1 && strings[1] == NULL, "Overwrote end of string array; rc=%i, str='%s'\n", rc, strings[1]);
 535 }
 536
 537 #define propcmp(p1, p2) (((p1)->length == (p2)->length) && \
 538                         (p1)->value && (p2)->value && \
 539                         !memcmp((p1)->value, (p2)->value, (p1)->length) && \
 540                         !strcmp((p1)->name, (p2)->name))
 541 static void __init of_unittest_property_copy(void)
 542 {
 543 #ifdef CONFIG_OF_DYNAMIC
 544         struct property p1 = { .name = "p1", .length = 0, .value = "" };
 545         struct property p2 = { .name = "p2", .length = 5, .value = "abcd" };
 546         struct property *new;
 547
 548         new = __of_prop_dup(&p1, GFP_KERNEL);
 549         unittest(new && propcmp(&p1, new), "empty property didn't copy correctly\n");
 550         kfree(new->value);
 551         kfree(new->name);
 552         kfree(new);
 553
 554         new = __of_prop_dup(&p2, GFP_KERNEL);
 555         unittest(new && propcmp(&p2, new), "non-empty property didn't copy correctly\n");
 556         kfree(new->value);
 557         kfree(new->name);
 558         kfree(new);
 559 #endif
 560 }
 561
 562 static void __init of_unittest_changeset(void)
 563 {
 564 #ifdef CONFIG_OF_DYNAMIC
 565         struct property *ppadd, padd = { .name = "prop-add", .length = 0, .value = "" };
 566         struct property *ppupdate, pupdate = { .name = "prop-update", .length = 5, .value = "abcd" };
 567         struct property *ppremove;
 568         struct device_node *n1, *n2, *n21, *nremove, *parent, *np;
 569         struct of_changeset chgset;
 570
 571         n1 = __of_node_dup(NULL, "/testcase-data/changeset/n1");
 572         unittest(n1, "testcase setup failure\n");
 573         n2 = __of_node_dup(NULL, "/testcase-data/changeset/n2");
 574         unittest(n2, "testcase setup failure\n");
 575         n21 = __of_node_dup(NULL, "%s/%s", "/testcase-data/changeset/n2", "n21");
 576         unittest(n21, "testcase setup failure %p\n", n21);
 577         nremove = of_find_node_by_path("/testcase-data/changeset/node-remove");
 578         unittest(nremove, "testcase setup failure\n");
 579         ppadd = __of_prop_dup(&padd, GFP_KERNEL);
 580         unittest(ppadd, "testcase setup failure\n");
 581         ppupdate = __of_prop_dup(&pupdate, GFP_KERNEL);
 582         unittest(ppupdate, "testcase setup failure\n");
 583         parent = nremove->parent;
 584         n1->parent = parent;
 585         n2->parent = parent;
 586         n21->parent = n2;
 587         n2->child = n21;
 588         ppremove = of_find_property(parent, "prop-remove", NULL);
 589         unittest(ppremove, "failed to find removal prop");
 590
 591         of_changeset_init(&chgset);
 592         unittest(!of_changeset_attach_node(&chgset, n1), "fail attach n1\n");
 593         unittest(!of_changeset_attach_node(&chgset, n2), "fail attach n2\n");
 594         unittest(!of_changeset_detach_node(&chgset, nremove), "fail remove node\n");
 595         unittest(!of_changeset_attach_node(&chgset, n21), "fail attach n21\n");
 596         unittest(!of_changeset_add_property(&chgset, parent, ppadd), "fail add prop\n");
 597         unittest(!of_changeset_update_property(&chgset, parent, ppupdate), "fail update prop\n");
 598         unittest(!of_changeset_remove_property(&chgset, parent, ppremove), "fail remove prop\n");
 599         unittest(!of_changeset_apply(&chgset), "apply failed\n");
 600
 601         /* Make sure node names are constructed correctly */
 602         unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n21")),
 603                  "'%pOF' not added\n", n21);
 604         of_node_put(np);
 605
 606         unittest(!of_changeset_revert(&chgset), "revert failed\n");
 607
 608         of_changeset_destroy(&chgset);
 609 #endif
 610 }
 611
 612 static void __init of_unittest_parse_interrupts(void)
 613 {
 614         struct device_node *np;
 615         struct of_phandle_args args;
 616         int i, rc;
 617
 618         np = of_find_node_by_path("/testcase-data/interrupts/interrupts0");
 619         if (!np) {
 620                 pr_err("missing testcase data\n");
 621                 return;
 622         }
 623
 624         for (i = 0; i < 4; i++) {
 625                 bool passed = true;
 626
 627                 args.args_count = 0;
 628                 rc = of_irq_parse_one(np, i, &args);
 629
 630                 passed &= !rc;
 631                 passed &= (args.args_count == 1);
 632                 passed &= (args.args[0] == (i + 1));
 633
 634                 unittest(passed, "index %i - data error on node %pOF rc=%i\n",
 635                          i, args.np, rc);
 636         }
 637         of_node_put(np);
 638
 639         np = of_find_node_by_path("/testcase-data/interrupts/interrupts1");
 640         if (!np) {
 641                 pr_err("missing testcase data\n");
 642                 return;
 643         }
 644
 645         for (i = 0; i < 4; i++) {
 646                 bool passed = true;
 647
 648                 args.args_count = 0;
 649                 rc = of_irq_parse_one(np, i, &args);
 650
 651                 /* Test the values from tests-phandle.dtsi */
 652                 switch (i) {
 653                 case 0:
 654                         passed &= !rc;
 655                         passed &= (args.args_count == 1);
 656                         passed &= (args.args[0] == 9);
 657                         break;
 658                 case 1:
 659                         passed &= !rc;
 660                         passed &= (args.args_count == 3);
 661                         passed &= (args.args[0] == 10);
 662                         passed &= (args.args[1] == 11);
 663                         passed &= (args.args[2] == 12);
 664                         break;
 665                 case 2:
 666                         passed &= !rc;
 667                         passed &= (args.args_count == 2);
 668                         passed &= (args.args[0] == 13);
 669                         passed &= (args.args[1] == 14);
 670                         break;
 671                 case 3:
 672                         passed &= !rc;
 673                         passed &= (args.args_count == 2);
 674                         passed &= (args.args[0] == 15);
 675                         passed &= (args.args[1] == 16);
 676                         break;
 677                 default:
 678                         passed = false;
 679                 }
 680                 unittest(passed, "index %i - data error on node %pOF rc=%i\n",
 681                          i, args.np, rc);
 682         }
 683         of_node_put(np);
 684 }
 685
 686 static void __init of_unittest_parse_interrupts_extended(void)
 687 {
 688         struct device_node *np;
 689         struct of_phandle_args args;
 690         int i, rc;
 691
 692         np = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0");
 693         if (!np) {
 694                 pr_err("missing testcase data\n");
 695                 return;
 696         }
 697
 698         for (i = 0; i < 7; i++) {
 699                 bool passed = true;
 700
 701                 rc = of_irq_parse_one(np, i, &args);
 702
 703                 /* Test the values from tests-phandle.dtsi */
 704                 switch (i) {
 705                 case 0:
 706                         passed &= !rc;
 707                         passed &= (args.args_count == 1);
 708                         passed &= (args.args[0] == 1);
 709                         break;
 710                 case 1:
 711                         passed &= !rc;
 712                         passed &= (args.args_count == 3);
 713                         passed &= (args.args[0] == 2);
 714                         passed &= (args.args[1] == 3);
 715                         passed &= (args.args[2] == 4);
 716                         break;
 717                 case 2:
 718                         passed &= !rc;
 719                         passed &= (args.args_count == 2);
 720                         passed &= (args.args[0] == 5);
 721                         passed &= (args.args[1] == 6);
 722                         break;
 723                 case 3:
 724                         passed &= !rc;
 725                         passed &= (args.args_count == 1);
 726                         passed &= (args.args[0] == 9);
 727                         break;
 728                 case 4:
 729                         passed &= !rc;
 730                         passed &= (args.args_count == 3);
 731                         passed &= (args.args[0] == 10);
 732                         passed &= (args.args[1] == 11);
 733                         passed &= (args.args[2] == 12);
 734                         break;
 735                 case 5:
 736                         passed &= !rc;
 737                         passed &= (args.args_count == 2);
 738                         passed &= (args.args[0] == 13);
 739                         passed &= (args.args[1] == 14);
 740                         break;
 741                 case 6:
 742                         passed &= !rc;
 743                         passed &= (args.args_count == 1);
 744                         passed &= (args.args[0] == 15);
 745                         break;
 746                 default:
 747                         passed = false;
 748                 }
 749
 750                 unittest(passed, "index %i - data error on node %pOF rc=%i\n",
 751                          i, args.np, rc);
 752         }
 753         of_node_put(np);
 754 }
 755
 756 static const struct of_device_id match_node_table[] = {
 757         { .data = "A", .name = "name0", }, /* Name alone is lowest priority */
 758         { .data = "B", .type = "type1", }, /* followed by type alone */
 759
 760         { .data = "Ca", .name = "name2", .type = "type1", }, /* followed by both together */
 761         { .data = "Cb", .name = "name2", }, /* Only match when type doesn't match */
 762         { .data = "Cc", .name = "name2", .type = "type2", },
 763
 764         { .data = "E", .compatible = "compat3" },
 765         { .data = "G", .compatible = "compat2", },
 766         { .data = "H", .compatible = "compat2", .name = "name5", },
 767         { .data = "I", .compatible = "compat2", .type = "type1", },
 768         { .data = "J", .compatible = "compat2", .type = "type1", .name = "name8", },
 769         { .data = "K", .compatible = "compat2", .name = "name9", },
 770         {}
 771 };
 772
 773 static struct {
 774         const char *path;
 775         const char *data;
 776 } match_node_tests[] = {
 777         { .path = "/testcase-data/match-node/name0", .data = "A", },
 778         { .path = "/testcase-data/match-node/name1", .data = "B", },
 779         { .path = "/testcase-data/match-node/a/name2", .data = "Ca", },
 780         { .path = "/testcase-data/match-node/b/name2", .data = "Cb", },
 781         { .path = "/testcase-data/match-node/c/name2", .data = "Cc", },
 782         { .path = "/testcase-data/match-node/name3", .data = "E", },
 783         { .path = "/testcase-data/match-node/name4", .data = "G", },
 784         { .path = "/testcase-data/match-node/name5", .data = "H", },
 785         { .path = "/testcase-data/match-node/name6", .data = "G", },
 786         { .path = "/testcase-data/match-node/name7", .data = "I", },
 787         { .path = "/testcase-data/match-node/name8", .data = "J", },
 788         { .path = "/testcase-data/match-node/name9", .data = "K", },
 789 };
 790
 791 static void __init of_unittest_match_node(void)
 792 {
 793         struct device_node *np;
 794         const struct of_device_id *match;
 795         int i;
 796
 797         for (i = 0; i < ARRAY_SIZE(match_node_tests); i++) {
 798                 np = of_find_node_by_path(match_node_tests[i].path);
 799                 if (!np) {
 800                         unittest(0, "missing testcase node %s\n",
 801                                 match_node_tests[i].path);
 802                         continue;
 803                 }
 804
 805                 match = of_match_node(match_node_table, np);
 806                 if (!match) {
 807                         unittest(0, "%s didn't match anything\n",
 808                                 match_node_tests[i].path);
 809                         continue;
 810                 }
 811
 812                 if (strcmp(match->data, match_node_tests[i].data) != 0) {
 813                         unittest(0, "%s got wrong match. expected %s, got %s\n",
 814                                 match_node_tests[i].path, match_node_tests[i].data,
 815                                 (const char *)match->data);
 816                         continue;
 817                 }
 818                 unittest(1, "passed");
 819         }
 820 }
 821
 822 static struct resource test_bus_res = {
 823         .start = 0xfffffff8,
 824         .end = 0xfffffff9,
 825         .flags = IORESOURCE_MEM,
 826 };
 827 static const struct platform_device_info test_bus_info = {
 828         .name = "unittest-bus",
 829 };
 830 static void __init of_unittest_platform_populate(void)
 831 {
 832         int irq, rc;
 833         struct device_node *np, *child, *grandchild;
 834         struct platform_device *pdev, *test_bus;
 835         const struct of_device_id match[] = {
 836                 { .compatible = "test-device", },
 837                 {}
 838         };
 839
 840         np = of_find_node_by_path("/testcase-data");
 841         of_platform_default_populate(np, NULL, NULL);
 842
 843         /* Test that a missing irq domain returns -EPROBE_DEFER */
 844         np = of_find_node_by_path("/testcase-data/testcase-device1");
 845         pdev = of_find_device_by_node(np);
 846         unittest(pdev, "device 1 creation failed\n");
 847
 848         irq = platform_get_irq(pdev, 0);
 849         unittest(irq == -EPROBE_DEFER, "device deferred probe failed - %d\n", irq);
 850
 851         /* Test that a parsing failure does not return -EPROBE_DEFER */
 852         np = of_find_node_by_path("/testcase-data/testcase-device2");
 853         pdev = of_find_device_by_node(np);
 854         unittest(pdev, "device 2 creation failed\n");
 855         irq = platform_get_irq(pdev, 0);
 856         unittest(irq < 0 && irq != -EPROBE_DEFER, "device parsing error failed - %d\n", irq);
 857
 858         np = of_find_node_by_path("/testcase-data/platform-tests");
 859         unittest(np, "No testcase data in device tree\n");
 860         if (!np)
 861                 return;
 862
 863         test_bus = platform_device_register_full(&test_bus_info);
 864         rc = PTR_ERR_OR_ZERO(test_bus);
 865         unittest(!rc, "testbus registration failed; rc=%i\n", rc);
 866         if (rc)
 867                 return;
 868         test_bus->dev.of_node = np;
 869
 870         /*
 871          * Add a dummy resource to the test bus node after it is
 872          * registered to catch problems with un-inserted resources. The
 873          * DT code doesn't insert the resources, and it has caused the
 874          * kernel to oops in the past. This makes sure the same bug
 875          * doesn't crop up again.
 876          */
 877         platform_device_add_resources(test_bus, &test_bus_res, 1);
 878
 879         of_platform_populate(np, match, NULL, &test_bus->dev);
 880         for_each_child_of_node(np, child) {
 881                 for_each_child_of_node(child, grandchild)
 882                         unittest(of_find_device_by_node(grandchild),
 883                                  "Could not create device for node '%s'\n",
 884                                  grandchild->name);
 885         }
 886
 887         of_platform_depopulate(&test_bus->dev);
 888         for_each_child_of_node(np, child) {
 889                 for_each_child_of_node(child, grandchild)
 890                         unittest(!of_find_device_by_node(grandchild),
 891                                  "device didn't get destroyed '%s'\n",
 892                                  grandchild->name);
 893         }
 894
 895         platform_device_unregister(test_bus);
 896         of_node_put(np);
 897 }
 898
 899 /**
 900  *      update_node_properties - adds the properties
 901  *      of np into dup node (present in live tree) and
 902  *      updates parent of children of np to dup.
 903  *
 904  *      @np:    node already present in live tree
 905  *      @dup:   node present in live tree to be updated
 906  */
 907 static void update_node_properties(struct device_node *np,
 908                                         struct device_node *dup)
 909 {
 910         struct property *prop;
 911         struct device_node *child;
 912
 913         for_each_property_of_node(np, prop)
 914                 of_add_property(dup, prop);
 915
 916         for_each_child_of_node(np, child)
 917                 child->parent = dup;
 918 }
 919
 920 /**
 921  *      attach_node_and_children - attaches nodes
 922  *      and its children to live tree
 923  *
 924  *      @np:    Node to attach to live tree
 925  */
 926 static int attach_node_and_children(struct device_node *np)
 927 {
 928         struct device_node *next, *dup, *child;
 929         unsigned long flags;
 930         const char *full_name;
 931
 932         full_name = kasprintf(GFP_KERNEL, "%pOF", np);
 933         dup = of_find_node_by_path(full_name);
 934         kfree(full_name);
 935         if (dup) {
 936                 update_node_properties(np, dup);
 937                 return 0;
 938         }
 939
 940         child = np->child;
 941         np->child = NULL;
 942
 943         mutex_lock(&of_mutex);
 944         raw_spin_lock_irqsave(&devtree_lock, flags);
 945         np->sibling = np->parent->child;
 946         np->parent->child = np;
 947         of_node_clear_flag(np, OF_DETACHED);
 948         raw_spin_unlock_irqrestore(&devtree_lock, flags);
 949
 950         __of_attach_node_sysfs(np);
 951         mutex_unlock(&of_mutex);
 952
 953         while (child) {
 954                 next = child->sibling;
 955                 attach_node_and_children(child);
 956                 child = next;
 957         }
 958
 959         return 0;
 960 }
 961
 962 /**
 963  *      unittest_data_add - Reads, copies data from
 964  *      linked tree and attaches it to the live tree
 965  */
 966 static int __init unittest_data_add(void)
 967 {
 968         void *unittest_data;
 969         struct device_node *unittest_data_node, *np;
 970         /*
 971          * __dtb_testcases_begin[] and __dtb_testcases_end[] are magically
 972          * created by cmd_dt_S_dtb in scripts/Makefile.lib
 973          */
 974         extern uint8_t __dtb_testcases_begin[];
 975         extern uint8_t __dtb_testcases_end[];
 976         const int size = __dtb_testcases_end - __dtb_testcases_begin;
 977         int rc;
 978
 979         if (!size) {
 980                 pr_warn("%s: No testcase data to attach; not running tests\n",
 981                         __func__);
 982                 return -ENODATA;
 983         }
 984
 985         /* creating copy */
 986         unittest_data = kmemdup(__dtb_testcases_begin, size, GFP_KERNEL);
 987
 988         if (!unittest_data) {
 989                 pr_warn("%s: Failed to allocate memory for unittest_data; "
 990                         "not running tests\n", __func__);
 991                 return -ENOMEM;
 992         }
 993         of_fdt_unflatten_tree(unittest_data, NULL, &unittest_data_node);
 994         if (!unittest_data_node) {
 995                 pr_warn("%s: No tree to attach; not running tests\n", __func__);
 996                 return -ENODATA;
 997         }
 998
 999         /*
1000          * This lock normally encloses of_overlay_apply() as well as
1001          * of_resolve_phandles().
1002          */
1003         of_overlay_mutex_lock();
1004
1005         rc = of_resolve_phandles(unittest_data_node);
1006         if (rc) {
1007                 pr_err("%s: Failed to resolve phandles (rc=%i)\n", __func__, rc);
1008                 of_overlay_mutex_unlock();
1009                 return -EINVAL;
1010         }
1011
1012         if (!of_root) {
1013                 of_root = unittest_data_node;
1014                 for_each_of_allnodes(np)
1015                         __of_attach_node_sysfs(np);
1016                 of_aliases = of_find_node_by_path("/aliases");
1017                 of_chosen = of_find_node_by_path("/chosen");
1018                 of_overlay_mutex_unlock();
1019                 return 0;
1020         }
1021
1022         /* attach the sub-tree to live tree */
1023         np = unittest_data_node->child;
1024         while (np) {
1025                 struct device_node *next = np->sibling;
1026
1027                 np->parent = of_root;
1028                 attach_node_and_children(np);
1029                 np = next;
1030         }
1031
1032         of_overlay_mutex_unlock();
1033
1034         return 0;
1035 }
1036
1037 #ifdef CONFIG_OF_OVERLAY
1038
1039 static int unittest_probe(struct platform_device *pdev)
1040 {
1041         struct device *dev = &pdev->dev;
1042         struct device_node *np = dev->of_node;
1043
1044         if (np == NULL) {
1045                 dev_err(dev, "No OF data for device\n");
1046                 return -EINVAL;
1047
1048         }
1049
1050         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1051
1052         of_platform_populate(np, NULL, NULL, &pdev->dev);
1053
1054         return 0;
1055 }
1056
1057 static int unittest_remove(struct platform_device *pdev)
1058 {
1059         struct device *dev = &pdev->dev;
1060         struct device_node *np = dev->of_node;
1061
1062         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1063         return 0;
1064 }
1065
1066 static const struct of_device_id unittest_match[] = {
1067         { .compatible = "unittest", },
1068         {},
1069 };
1070
1071 static struct platform_driver unittest_driver = {
1072         .probe                  = unittest_probe,
1073         .remove                 = unittest_remove,
1074         .driver = {
1075                 .name           = "unittest",
1076                 .of_match_table = of_match_ptr(unittest_match),
1077         },
1078 };
1079
1080 /* get the platform device instantiated at the path */
1081 static struct platform_device *of_path_to_platform_device(const char *path)
1082 {
1083         struct device_node *np;
1084         struct platform_device *pdev;
1085
1086         np = of_find_node_by_path(path);
1087         if (np == NULL)
1088                 return NULL;
1089
1090         pdev = of_find_device_by_node(np);
1091         of_node_put(np);
1092
1093         return pdev;
1094 }
1095
1096 /* find out if a platform device exists at that path */
1097 static int of_path_platform_device_exists(const char *path)
1098 {
1099         struct platform_device *pdev;
1100
1101         pdev = of_path_to_platform_device(path);
1102         platform_device_put(pdev);
1103         return pdev != NULL;
1104 }
1105
1106 #if IS_BUILTIN(CONFIG_I2C)
1107
1108 /* get the i2c client device instantiated at the path */
1109 static struct i2c_client *of_path_to_i2c_client(const char *path)
1110 {
1111         struct device_node *np;
1112         struct i2c_client *client;
1113
1114         np = of_find_node_by_path(path);
1115         if (np == NULL)
1116                 return NULL;
1117
1118         client = of_find_i2c_device_by_node(np);
1119         of_node_put(np);
1120
1121         return client;
1122 }
1123
1124 /* find out if a i2c client device exists at that path */
1125 static int of_path_i2c_client_exists(const char *path)
1126 {
1127         struct i2c_client *client;
1128
1129         client = of_path_to_i2c_client(path);
1130         if (client)
1131                 put_device(&client->dev);
1132         return client != NULL;
1133 }
1134 #else
1135 static int of_path_i2c_client_exists(const char *path)
1136 {
1137         return 0;
1138 }
1139 #endif
1140
1141 enum overlay_type {
1142         PDEV_OVERLAY,
1143         I2C_OVERLAY
1144 };
1145
1146 static int of_path_device_type_exists(const char *path,
1147                 enum overlay_type ovtype)
1148 {
1149         switch (ovtype) {
1150         case PDEV_OVERLAY:
1151                 return of_path_platform_device_exists(path);
1152         case I2C_OVERLAY:
1153                 return of_path_i2c_client_exists(path);
1154         }
1155         return 0;
1156 }
1157
1158 static const char *unittest_path(int nr, enum overlay_type ovtype)
1159 {
1160         const char *base;
1161         static char buf[256];
1162
1163         switch (ovtype) {
1164         case PDEV_OVERLAY:
1165                 base = "/testcase-data/overlay-node/test-bus";
1166                 break;
1167         case I2C_OVERLAY:
1168                 base = "/testcase-data/overlay-node/test-bus/i2c-test-bus";
1169                 break;
1170         default:
1171                 buf[0] = '\0';
1172                 return buf;
1173         }
1174         snprintf(buf, sizeof(buf) - 1, "%s/test-unittest%d", base, nr);
1175         buf[sizeof(buf) - 1] = '\0';
1176         return buf;
1177 }
1178
1179 static int of_unittest_device_exists(int unittest_nr, enum overlay_type ovtype)
1180 {
1181         const char *path;
1182
1183         path = unittest_path(unittest_nr, ovtype);
1184
1185         switch (ovtype) {
1186         case PDEV_OVERLAY:
1187                 return of_path_platform_device_exists(path);
1188         case I2C_OVERLAY:
1189                 return of_path_i2c_client_exists(path);
1190         }
1191         return 0;
1192 }
1193
1194 static const char *overlay_path(int nr)
1195 {
1196         static char buf[256];
1197
1198         snprintf(buf, sizeof(buf) - 1,
1199                 "/testcase-data/overlay%d", nr);
1200         buf[sizeof(buf) - 1] = '\0';
1201
1202         return buf;
1203 }
1204
1205 static const char *bus_path = "/testcase-data/overlay-node/test-bus";
1206
1207 /* it is guaranteed that overlay ids are assigned in sequence */
1208 #define MAX_UNITTEST_OVERLAYS   256
1209 static unsigned long overlay_id_bits[BITS_TO_LONGS(MAX_UNITTEST_OVERLAYS)];
1210 static int overlay_first_id = -1;
1211
1212 static void of_unittest_track_overlay(int id)
1213 {
1214         if (overlay_first_id < 0)
1215                 overlay_first_id = id;
1216         id -= overlay_first_id;
1217
1218         /* we shouldn't need that many */
1219         BUG_ON(id >= MAX_UNITTEST_OVERLAYS);
1220         overlay_id_bits[BIT_WORD(id)] |= BIT_MASK(id);
1221 }
1222
1223 static void of_unittest_untrack_overlay(int id)
1224 {
1225         if (overlay_first_id < 0)
1226                 return;
1227         id -= overlay_first_id;
1228         BUG_ON(id >= MAX_UNITTEST_OVERLAYS);
1229         overlay_id_bits[BIT_WORD(id)] &= ~BIT_MASK(id);
1230 }
1231
1232 static void of_unittest_destroy_tracked_overlays(void)
1233 {
1234         int id, ret, defers, ovcs_id;
1235
1236         if (overlay_first_id < 0)
1237                 return;
1238
1239         /* try until no defers */
1240         do {
1241                 defers = 0;
1242                 /* remove in reverse order */
1243                 for (id = MAX_UNITTEST_OVERLAYS - 1; id >= 0; id--) {
1244                         if (!(overlay_id_bits[BIT_WORD(id)] & BIT_MASK(id)))
1245                                 continue;
1246
1247                         ovcs_id = id + overlay_first_id;
1248                         ret = of_overlay_remove(&ovcs_id);
1249                         if (ret == -ENODEV) {
1250                                 pr_warn("%s: no overlay to destroy for #%d\n",
1251                                         __func__, id + overlay_first_id);
1252                                 continue;
1253                         }
1254                         if (ret != 0) {
1255                                 defers++;
1256                                 pr_warn("%s: overlay destroy failed for #%d\n",
1257                                         __func__, id + overlay_first_id);
1258                                 continue;
1259                         }
1260
1261                         overlay_id_bits[BIT_WORD(id)] &= ~BIT_MASK(id);
1262                 }
1263         } while (defers > 0);
1264 }
1265
1266 static int of_unittest_apply_overlay(int overlay_nr, int unittest_nr,
1267                 int *overlay_id)
1268 {
1269         struct device_node *np = NULL;
1270         int ret;
1271
1272         np = of_find_node_by_path(overlay_path(overlay_nr));
1273         if (np == NULL) {
1274                 unittest(0, "could not find overlay node @\"%s\"\n",
1275                                 overlay_path(overlay_nr));
1276                 ret = -EINVAL;
1277                 goto out;
1278         }
1279
1280         *overlay_id = 0;
1281         ret = of_overlay_apply(np, overlay_id);
1282         if (ret < 0) {
1283                 unittest(0, "could not create overlay from \"%s\"\n",
1284                                 overlay_path(overlay_nr));
1285                 goto out;
1286         }
1287         of_unittest_track_overlay(*overlay_id);
1288
1289         ret = 0;
1290
1291 out:
1292         of_node_put(np);
1293
1294         return ret;
1295 }
1296
1297 /* apply an overlay while checking before and after states */
1298 static int of_unittest_apply_overlay_check(int overlay_nr, int unittest_nr,
1299                 int before, int after, enum overlay_type ovtype)
1300 {
1301         int ret, ovcs_id;
1302
1303         /* unittest device must not be in before state */
1304         if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
1305                 unittest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
1306                                 overlay_path(overlay_nr),
1307                                 unittest_path(unittest_nr, ovtype),
1308                                 !before ? "enabled" : "disabled");
1309                 return -EINVAL;
1310         }
1311
1312         ovcs_id = 0;
1313         ret = of_unittest_apply_overlay(overlay_nr, unittest_nr, &ovcs_id);
1314         if (ret != 0) {
1315                 /* of_unittest_apply_overlay already called unittest() */
1316                 return ret;
1317         }
1318
1319         /* unittest device must be to set to after state */
1320         if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
1321                 unittest(0, "overlay @\"%s\" failed to create @\"%s\" %s\n",
1322                                 overlay_path(overlay_nr),
1323                                 unittest_path(unittest_nr, ovtype),
1324                                 !after ? "enabled" : "disabled");
1325                 return -EINVAL;
1326         }
1327
1328         return 0;
1329 }
1330
1331 /* apply an overlay and then revert it while checking before, after states */
1332 static int of_unittest_apply_revert_overlay_check(int overlay_nr,
1333                 int unittest_nr, int before, int after,
1334                 enum overlay_type ovtype)
1335 {
1336         int ret, ovcs_id;
1337
1338         /* unittest device must be in before state */
1339         if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
1340                 unittest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
1341                                 overlay_path(overlay_nr),
1342                                 unittest_path(unittest_nr, ovtype),
1343                                 !before ? "enabled" : "disabled");
1344                 return -EINVAL;
1345         }
1346
1347         /* apply the overlay */
1348         ovcs_id = 0;
1349         ret = of_unittest_apply_overlay(overlay_nr, unittest_nr, &ovcs_id);
1350         if (ret != 0) {
1351                 /* of_unittest_apply_overlay already called unittest() */
1352                 return ret;
1353         }
1354
1355         /* unittest device must be in after state */
1356         if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
1357                 unittest(0, "overlay @\"%s\" failed to create @\"%s\" %s\n",
1358                                 overlay_path(overlay_nr),
1359                                 unittest_path(unittest_nr, ovtype),
1360                                 !after ? "enabled" : "disabled");
1361                 return -EINVAL;
1362         }
1363
1364         ret = of_overlay_remove(&ovcs_id);
1365         if (ret != 0) {
1366                 unittest(0, "overlay @\"%s\" failed to be destroyed @\"%s\"\n",
1367                                 overlay_path(overlay_nr),
1368                                 unittest_path(unittest_nr, ovtype));
1369                 return ret;
1370         }
1371
1372         /* unittest device must be again in before state */
1373         if (of_unittest_device_exists(unittest_nr, PDEV_OVERLAY) != before) {
1374                 unittest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
1375                                 overlay_path(overlay_nr),
1376                                 unittest_path(unittest_nr, ovtype),
1377                                 !before ? "enabled" : "disabled");
1378                 return -EINVAL;
1379         }
1380
1381         return 0;
1382 }
1383
1384 /* test activation of device */
1385 static void of_unittest_overlay_0(void)
1386 {
1387         int ret;
1388
1389         /* device should enable */
1390         ret = of_unittest_apply_overlay_check(0, 0, 0, 1, PDEV_OVERLAY);
1391         if (ret != 0)
1392                 return;
1393
1394         unittest(1, "overlay test %d passed\n", 0);
1395 }
1396
1397 /* test deactivation of device */
1398 static void of_unittest_overlay_1(void)
1399 {
1400         int ret;
1401
1402         /* device should disable */
1403         ret = of_unittest_apply_overlay_check(1, 1, 1, 0, PDEV_OVERLAY);
1404         if (ret != 0)
1405                 return;
1406
1407         unittest(1, "overlay test %d passed\n", 1);
1408 }
1409
1410 /* test activation of device */
1411 static void of_unittest_overlay_2(void)
1412 {
1413         int ret;
1414
1415         /* device should enable */
1416         ret = of_unittest_apply_overlay_check(2, 2, 0, 1, PDEV_OVERLAY);
1417         if (ret != 0)
1418                 return;
1419
1420         unittest(1, "overlay test %d passed\n", 2);
1421 }
1422
1423 /* test deactivation of device */
1424 static void of_unittest_overlay_3(void)
1425 {
1426         int ret;
1427
1428         /* device should disable */
1429         ret = of_unittest_apply_overlay_check(3, 3, 1, 0, PDEV_OVERLAY);
1430         if (ret != 0)
1431                 return;
1432
1433         unittest(1, "overlay test %d passed\n", 3);
1434 }
1435
1436 /* test activation of a full device node */
1437 static void of_unittest_overlay_4(void)
1438 {
1439         int ret;
1440
1441         /* device should disable */
1442         ret = of_unittest_apply_overlay_check(4, 4, 0, 1, PDEV_OVERLAY);
1443         if (ret != 0)
1444                 return;
1445
1446         unittest(1, "overlay test %d passed\n", 4);
1447 }
1448
1449 /* test overlay apply/revert sequence */
1450 static void of_unittest_overlay_5(void)
1451 {
1452         int ret;
1453
1454         /* device should disable */
1455         ret = of_unittest_apply_revert_overlay_check(5, 5, 0, 1, PDEV_OVERLAY);
1456         if (ret != 0)
1457                 return;
1458
1459         unittest(1, "overlay test %d passed\n", 5);
1460 }
1461
1462 /* test overlay application in sequence */
1463 static void of_unittest_overlay_6(void)
1464 {
1465         struct device_node *np;
1466         int ret, i, ov_id[2], ovcs_id;
1467         int overlay_nr = 6, unittest_nr = 6;
1468         int before = 0, after = 1;
1469
1470         /* unittest device must be in before state */
1471         for (i = 0; i < 2; i++) {
1472                 if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
1473                                 != before) {
1474                         unittest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
1475                                         overlay_path(overlay_nr + i),
1476                                         unittest_path(unittest_nr + i,
1477                                                 PDEV_OVERLAY),
1478                                         !before ? "enabled" : "disabled");
1479                         return;
1480                 }
1481         }
1482
1483         /* apply the overlays */
1484         for (i = 0; i < 2; i++) {
1485
1486                 np = of_find_node_by_path(overlay_path(overlay_nr + i));
1487                 if (np == NULL) {
1488                         unittest(0, "could not find overlay node @\"%s\"\n",
1489                                         overlay_path(overlay_nr + i));
1490                         return;
1491                 }
1492
1493                 ovcs_id = 0;
1494                 ret = of_overlay_apply(np, &ovcs_id);
1495                 if (ret < 0)  {
1496                         unittest(0, "could not create overlay from \"%s\"\n",
1497                                         overlay_path(overlay_nr + i));
1498                         return;
1499                 }
1500                 ov_id[i] = ovcs_id;
1501                 of_unittest_track_overlay(ov_id[i]);
1502         }
1503
1504         for (i = 0; i < 2; i++) {
1505                 /* unittest device must be in after state */
1506                 if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
1507                                 != after) {
1508                         unittest(0, "overlay @\"%s\" failed @\"%s\" %s\n",
1509                                         overlay_path(overlay_nr + i),
1510                                         unittest_path(unittest_nr + i,
1511                                                 PDEV_OVERLAY),
1512                                         !after ? "enabled" : "disabled");
1513                         return;
1514                 }
1515         }
1516
1517         for (i = 1; i >= 0; i--) {
1518                 ovcs_id = ov_id[i];
1519                 ret = of_overlay_remove(&ovcs_id);
1520                 if (ret != 0) {
1521                         unittest(0, "overlay @\"%s\" failed destroy @\"%s\"\n",
1522                                         overlay_path(overlay_nr + i),
1523                                         unittest_path(unittest_nr + i,
1524                                                 PDEV_OVERLAY));
1525                         return;
1526                 }
1527                 of_unittest_untrack_overlay(ov_id[i]);
1528         }
1529
1530         for (i = 0; i < 2; i++) {
1531                 /* unittest device must be again in before state */
1532                 if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
1533                                 != before) {
1534                         unittest(0, "overlay @\"%s\" with device @\"%s\" %s\n",
1535                                         overlay_path(overlay_nr + i),
1536                                         unittest_path(unittest_nr + i,
1537                                                 PDEV_OVERLAY),
1538                                         !before ? "enabled" : "disabled");
1539                         return;
1540                 }
1541         }
1542
1543         unittest(1, "overlay test %d passed\n", 6);
1544 }
1545
1546 /* test overlay application in sequence */
1547 static void of_unittest_overlay_8(void)
1548 {
1549         struct device_node *np;
1550         int ret, i, ov_id[2], ovcs_id;
1551         int overlay_nr = 8, unittest_nr = 8;
1552
1553         /* we don't care about device state in this test */
1554
1555         /* apply the overlays */
1556         for (i = 0; i < 2; i++) {
1557
1558                 np = of_find_node_by_path(overlay_path(overlay_nr + i));
1559                 if (np == NULL) {
1560                         unittest(0, "could not find overlay node @\"%s\"\n",
1561                                         overlay_path(overlay_nr + i));
1562                         return;
1563                 }
1564
1565                 ovcs_id = 0;
1566                 ret = of_overlay_apply(np, &ovcs_id);
1567                 if (ret < 0)  {
1568                         unittest(0, "could not create overlay from \"%s\"\n",
1569                                         overlay_path(overlay_nr + i));
1570                         return;
1571                 }
1572                 ov_id[i] = ovcs_id;
1573                 of_unittest_track_overlay(ov_id[i]);
1574         }
1575
1576         /* now try to remove first overlay (it should fail) */
1577         ovcs_id = ov_id[0];
1578         ret = of_overlay_remove(&ovcs_id);
1579         if (ret == 0) {
1580                 unittest(0, "overlay @\"%s\" was destroyed @\"%s\"\n",
1581                                 overlay_path(overlay_nr + 0),
1582                                 unittest_path(unittest_nr,
1583                                         PDEV_OVERLAY));
1584                 return;
1585         }
1586
1587         /* removing them in order should work */
1588         for (i = 1; i >= 0; i--) {
1589                 ovcs_id = ov_id[i];
1590                 ret = of_overlay_remove(&ovcs_id);
1591                 if (ret != 0) {
1592                         unittest(0, "overlay @\"%s\" not destroyed @\"%s\"\n",
1593                                         overlay_path(overlay_nr + i),
1594                                         unittest_path(unittest_nr,
1595                                                 PDEV_OVERLAY));
1596                         return;
1597                 }
1598                 of_unittest_untrack_overlay(ov_id[i]);
1599         }
1600
1601         unittest(1, "overlay test %d passed\n", 8);
1602 }
1603
1604 /* test insertion of a bus with parent devices */
1605 static void of_unittest_overlay_10(void)
1606 {
1607         int ret;
1608         char *child_path;
1609
1610         /* device should disable */
1611         ret = of_unittest_apply_overlay_check(10, 10, 0, 1, PDEV_OVERLAY);
1612         if (unittest(ret == 0,
1613                         "overlay test %d failed; overlay application\n", 10))
1614                 return;
1615
1616         child_path = kasprintf(GFP_KERNEL, "%s/test-unittest101",
1617                         unittest_path(10, PDEV_OVERLAY));
1618         if (unittest(child_path, "overlay test %d failed; kasprintf\n", 10))
1619                 return;
1620
1621         ret = of_path_device_type_exists(child_path, PDEV_OVERLAY);
1622         kfree(child_path);
1623         if (unittest(ret, "overlay test %d failed; no child device\n", 10))
1624                 return;
1625 }
1626
1627 /* test insertion of a bus with parent devices (and revert) */
1628 static void of_unittest_overlay_11(void)
1629 {
1630         int ret;
1631
1632         /* device should disable */
1633         ret = of_unittest_apply_revert_overlay_check(11, 11, 0, 1,
1634                         PDEV_OVERLAY);
1635         if (unittest(ret == 0,
1636                         "overlay test %d failed; overlay application\n", 11))
1637                 return;
1638 }
1639
1640 #if IS_BUILTIN(CONFIG_I2C) && IS_ENABLED(CONFIG_OF_OVERLAY)
1641
1642 struct unittest_i2c_bus_data {
1643         struct platform_device  *pdev;
1644         struct i2c_adapter      adap;
1645 };
1646
1647 static int unittest_i2c_master_xfer(struct i2c_adapter *adap,
1648                 struct i2c_msg *msgs, int num)
1649 {
1650         struct unittest_i2c_bus_data *std = i2c_get_adapdata(adap);
1651
1652         (void)std;
1653
1654         return num;
1655 }
1656
1657 static u32 unittest_i2c_functionality(struct i2c_adapter *adap)
1658 {
1659         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
1660 }
1661
1662 static const struct i2c_algorithm unittest_i2c_algo = {
1663         .master_xfer    = unittest_i2c_master_xfer,
1664         .functionality  = unittest_i2c_functionality,
1665 };
1666
1667 static int unittest_i2c_bus_probe(struct platform_device *pdev)
1668 {
1669         struct device *dev = &pdev->dev;
1670         struct device_node *np = dev->of_node;
1671         struct unittest_i2c_bus_data *std;
1672         struct i2c_adapter *adap;
1673         int ret;
1674
1675         if (np == NULL) {
1676                 dev_err(dev, "No OF data for device\n");
1677                 return -EINVAL;
1678
1679         }
1680
1681         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1682
1683         std = devm_kzalloc(dev, sizeof(*std), GFP_KERNEL);
1684         if (!std) {
1685                 dev_err(dev, "Failed to allocate unittest i2c data\n");
1686                 return -ENOMEM;
1687         }
1688
1689         /* link them together */
1690         std->pdev = pdev;
1691         platform_set_drvdata(pdev, std);
1692
1693         adap = &std->adap;
1694         i2c_set_adapdata(adap, std);
1695         adap->nr = -1;
1696         strlcpy(adap->name, pdev->name, sizeof(adap->name));
1697         adap->class = I2C_CLASS_DEPRECATED;
1698         adap->algo = &unittest_i2c_algo;
1699         adap->dev.parent = dev;
1700         adap->dev.of_node = dev->of_node;
1701         adap->timeout = 5 * HZ;
1702         adap->retries = 3;
1703
1704         ret = i2c_add_numbered_adapter(adap);
1705         if (ret != 0) {
1706                 dev_err(dev, "Failed to add I2C adapter\n");
1707                 return ret;
1708         }
1709
1710         return 0;
1711 }
1712
1713 static int unittest_i2c_bus_remove(struct platform_device *pdev)
1714 {
1715         struct device *dev = &pdev->dev;
1716         struct device_node *np = dev->of_node;
1717         struct unittest_i2c_bus_data *std = platform_get_drvdata(pdev);
1718
1719         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1720         i2c_del_adapter(&std->adap);
1721
1722         return 0;
1723 }
1724
1725 static const struct of_device_id unittest_i2c_bus_match[] = {
1726         { .compatible = "unittest-i2c-bus", },
1727         {},
1728 };
1729
1730 static struct platform_driver unittest_i2c_bus_driver = {
1731         .probe                  = unittest_i2c_bus_probe,
1732         .remove                 = unittest_i2c_bus_remove,
1733         .driver = {
1734                 .name           = "unittest-i2c-bus",
1735                 .of_match_table = of_match_ptr(unittest_i2c_bus_match),
1736         },
1737 };
1738
1739 static int unittest_i2c_dev_probe(struct i2c_client *client,
1740                 const struct i2c_device_id *id)
1741 {
1742         struct device *dev = &client->dev;
1743         struct device_node *np = client->dev.of_node;
1744
1745         if (!np) {
1746                 dev_err(dev, "No OF node\n");
1747                 return -EINVAL;
1748         }
1749
1750         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1751
1752         return 0;
1753 };
1754
1755 static int unittest_i2c_dev_remove(struct i2c_client *client)
1756 {
1757         struct device *dev = &client->dev;
1758         struct device_node *np = client->dev.of_node;
1759
1760         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1761         return 0;
1762 }
1763
1764 static const struct i2c_device_id unittest_i2c_dev_id[] = {
1765         { .name = "unittest-i2c-dev" },
1766         { }
1767 };
1768
1769 static struct i2c_driver unittest_i2c_dev_driver = {
1770         .driver = {
1771                 .name = "unittest-i2c-dev",
1772         },
1773         .probe = unittest_i2c_dev_probe,
1774         .remove = unittest_i2c_dev_remove,
1775         .id_table = unittest_i2c_dev_id,
1776 };
1777
1778 #if IS_BUILTIN(CONFIG_I2C_MUX)
1779
1780 static int unittest_i2c_mux_select_chan(struct i2c_mux_core *muxc, u32 chan)
1781 {
1782         return 0;
1783 }
1784
1785 static int unittest_i2c_mux_probe(struct i2c_client *client,
1786                 const struct i2c_device_id *id)
1787 {
1788         int ret, i, nchans;
1789         struct device *dev = &client->dev;
1790         struct i2c_adapter *adap = to_i2c_adapter(dev->parent);
1791         struct device_node *np = client->dev.of_node, *child;
1792         struct i2c_mux_core *muxc;
1793         u32 reg, max_reg;
1794
1795         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1796
1797         if (!np) {
1798                 dev_err(dev, "No OF node\n");
1799                 return -EINVAL;
1800         }
1801
1802         max_reg = (u32)-1;
1803         for_each_child_of_node(np, child) {
1804                 ret = of_property_read_u32(child, "reg", &reg);
1805                 if (ret)
1806                         continue;
1807                 if (max_reg == (u32)-1 || reg > max_reg)
1808                         max_reg = reg;
1809         }
1810         nchans = max_reg == (u32)-1 ? 0 : max_reg + 1;
1811         if (nchans == 0) {
1812                 dev_err(dev, "No channels\n");
1813                 return -EINVAL;
1814         }
1815
1816         muxc = i2c_mux_alloc(adap, dev, nchans, 0, 0,
1817                              unittest_i2c_mux_select_chan, NULL);
1818         if (!muxc)
1819                 return -ENOMEM;
1820         for (i = 0; i < nchans; i++) {
1821                 ret = i2c_mux_add_adapter(muxc, 0, i, 0);
1822                 if (ret) {
1823                         dev_err(dev, "Failed to register mux #%d\n", i);
1824                         i2c_mux_del_adapters(muxc);
1825                         return -ENODEV;
1826                 }
1827         }
1828
1829         i2c_set_clientdata(client, muxc);
1830
1831         return 0;
1832 };
1833
1834 static int unittest_i2c_mux_remove(struct i2c_client *client)
1835 {
1836         struct device *dev = &client->dev;
1837         struct device_node *np = client->dev.of_node;
1838         struct i2c_mux_core *muxc = i2c_get_clientdata(client);
1839
1840         dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
1841         i2c_mux_del_adapters(muxc);
1842         return 0;
1843 }
1844
1845 static const struct i2c_device_id unittest_i2c_mux_id[] = {
1846         { .name = "unittest-i2c-mux" },
1847         { }
1848 };
1849
1850 static struct i2c_driver unittest_i2c_mux_driver = {
1851         .driver = {
1852                 .name = "unittest-i2c-mux",
1853         },
1854         .probe = unittest_i2c_mux_probe,
1855         .remove = unittest_i2c_mux_remove,
1856         .id_table = unittest_i2c_mux_id,
1857 };
1858
1859 #endif
1860
1861 static int of_unittest_overlay_i2c_init(void)
1862 {
1863         int ret;
1864
1865         ret = i2c_add_driver(&unittest_i2c_dev_driver);
1866         if (unittest(ret == 0,
1867                         "could not register unittest i2c device driver\n"))
1868                 return ret;
1869
1870         ret = platform_driver_register(&unittest_i2c_bus_driver);
1871         if (unittest(ret == 0,
1872                         "could not register unittest i2c bus driver\n"))
1873                 return ret;
1874
1875 #if IS_BUILTIN(CONFIG_I2C_MUX)
1876         ret = i2c_add_driver(&unittest_i2c_mux_driver);
1877         if (unittest(ret == 0,
1878                         "could not register unittest i2c mux driver\n"))
1879                 return ret;
1880 #endif
1881
1882         return 0;
1883 }
1884
1885 static void of_unittest_overlay_i2c_cleanup(void)
1886 {
1887 #if IS_BUILTIN(CONFIG_I2C_MUX)
1888         i2c_del_driver(&unittest_i2c_mux_driver);
1889 #endif
1890         platform_driver_unregister(&unittest_i2c_bus_driver);
1891         i2c_del_driver(&unittest_i2c_dev_driver);
1892 }
1893
1894 static void of_unittest_overlay_i2c_12(void)
1895 {
1896         int ret;
1897
1898         /* device should enable */
1899         ret = of_unittest_apply_overlay_check(12, 12, 0, 1, I2C_OVERLAY);
1900         if (ret != 0)
1901                 return;
1902
1903         unittest(1, "overlay test %d passed\n", 12);
1904 }
1905
1906 /* test deactivation of device */
1907 static void of_unittest_overlay_i2c_13(void)
1908 {
1909         int ret;
1910
1911         /* device should disable */
1912         ret = of_unittest_apply_overlay_check(13, 13, 1, 0, I2C_OVERLAY);
1913         if (ret != 0)
1914                 return;
1915
1916         unittest(1, "overlay test %d passed\n", 13);
1917 }
1918
1919 /* just check for i2c mux existence */
1920 static void of_unittest_overlay_i2c_14(void)
1921 {
1922 }
1923
1924 static void of_unittest_overlay_i2c_15(void)
1925 {
1926         int ret;
1927
1928         /* device should enable */
1929         ret = of_unittest_apply_overlay_check(15, 15, 0, 1, I2C_OVERLAY);
1930         if (ret != 0)
1931                 return;
1932
1933         unittest(1, "overlay test %d passed\n", 15);
1934 }
1935
1936 #else
1937
1938 static inline void of_unittest_overlay_i2c_14(void) { }
1939 static inline void of_unittest_overlay_i2c_15(void) { }
1940
1941 #endif
1942
1943 static void __init of_unittest_overlay(void)
1944 {
1945         struct device_node *bus_np = NULL;
1946         int ret;
1947
1948         ret = platform_driver_register(&unittest_driver);
1949         if (ret != 0) {
1950                 unittest(0, "could not register unittest driver\n");
1951                 goto out;
1952         }
1953
1954         bus_np = of_find_node_by_path(bus_path);
1955         if (bus_np == NULL) {
1956                 unittest(0, "could not find bus_path \"%s\"\n", bus_path);
1957                 goto out;
1958         }
1959
1960         ret = of_platform_default_populate(bus_np, NULL, NULL);
1961         if (ret != 0) {
1962                 unittest(0, "could not populate bus @ \"%s\"\n", bus_path);
1963                 goto out;
1964         }
1965
1966         if (!of_unittest_device_exists(100, PDEV_OVERLAY)) {
1967                 unittest(0, "could not find unittest0 @ \"%s\"\n",
1968                                 unittest_path(100, PDEV_OVERLAY));
1969                 goto out;
1970         }
1971
1972         if (of_unittest_device_exists(101, PDEV_OVERLAY)) {
1973                 unittest(0, "unittest1 @ \"%s\" should not exist\n",
1974                                 unittest_path(101, PDEV_OVERLAY));
1975                 goto out;
1976         }
1977
1978         unittest(1, "basic infrastructure of overlays passed");
1979
1980         /* tests in sequence */
1981         of_unittest_overlay_0();
1982         of_unittest_overlay_1();
1983         of_unittest_overlay_2();
1984         of_unittest_overlay_3();
1985         of_unittest_overlay_4();
1986         of_unittest_overlay_5();
1987         of_unittest_overlay_6();
1988         of_unittest_overlay_8();
1989
1990         of_unittest_overlay_10();
1991         of_unittest_overlay_11();
1992
1993 #if IS_BUILTIN(CONFIG_I2C)
1994         if (unittest(of_unittest_overlay_i2c_init() == 0, "i2c init failed\n"))
1995                 goto out;
1996
1997         of_unittest_overlay_i2c_12();
1998         of_unittest_overlay_i2c_13();
1999         of_unittest_overlay_i2c_14();
2000         of_unittest_overlay_i2c_15();
2001
2002         of_unittest_overlay_i2c_cleanup();
2003 #endif
2004
2005         of_unittest_destroy_tracked_overlays();
2006
2007 out:
2008         of_node_put(bus_np);
2009 }
2010
2011 #else
2012 static inline void __init of_unittest_overlay(void) { }
2013 #endif
2014
2015 #ifdef CONFIG_OF_OVERLAY
2016
2017 /*
2018  * __dtb_ot_begin[] and __dtb_ot_end[] are created by cmd_dt_S_dtb
2019  * in scripts/Makefile.lib
2020  */
2021
2022 #define OVERLAY_INFO_EXTERN(name) \
2023         extern uint8_t __dtb_##name##_begin[]; \
2024         extern uint8_t __dtb_##name##_end[]
2025
2026 #define OVERLAY_INFO(name, expected) \
2027 {       .dtb_begin       = __dtb_##name##_begin, \
2028         .dtb_end         = __dtb_##name##_end, \
2029         .expected_result = expected, \
2030 }
2031
2032 struct overlay_info {
2033         uint8_t            *dtb_begin;
2034         uint8_t            *dtb_end;
2035         void               *data;
2036         struct device_node *np_overlay;
2037         int                expected_result;
2038         int                overlay_id;
2039 };
2040
2041 OVERLAY_INFO_EXTERN(overlay_base);
2042 OVERLAY_INFO_EXTERN(overlay);
2043 OVERLAY_INFO_EXTERN(overlay_bad_phandle);
2044 OVERLAY_INFO_EXTERN(overlay_bad_symbol);
2045
2046 /* order of entries is hard-coded into users of overlays[] */
2047 static struct overlay_info overlays[] = {
2048         OVERLAY_INFO(overlay_base, -9999),
2049         OVERLAY_INFO(overlay, 0),
2050         OVERLAY_INFO(overlay_bad_phandle, -EINVAL),
2051         OVERLAY_INFO(overlay_bad_symbol, -EINVAL),
2052         {}
2053 };
2054
2055 static struct device_node *overlay_base_root;
2056
2057 static void * __init dt_alloc_memory(u64 size, u64 align)
2058 {
2059         return memblock_virt_alloc(size, align);
2060 }
2061
2062 /*
2063  * Create base device tree for the overlay unittest.
2064  *
2065  * This is called from very early boot code.
2066  *
2067  * Do as much as possible the same way as done in __unflatten_device_tree
2068  * and other early boot steps for the normal FDT so that the overlay base
2069  * unflattened tree will have the same characteristics as the real tree
2070  * (such as having memory allocated by the early allocator).  The goal
2071  * is to test "the real thing" as much as possible, and test "test setup
2072  * code" as little as possible.
2073  *
2074  * Have to stop before resolving phandles, because that uses kmalloc.
2075  */
2076 void __init unittest_unflatten_overlay_base(void)
2077 {
2078         struct overlay_info *info;
2079         u32 data_size;
2080         u32 size;
2081
2082         info = &overlays[0];
2083
2084         if (info->expected_result != -9999) {
2085                 pr_err("No dtb 'overlay_base' to attach\n");
2086                 return;
2087         }
2088
2089         data_size = info->dtb_end - info->dtb_begin;
2090         if (!data_size) {
2091                 pr_err("No dtb 'overlay_base' to attach\n");
2092                 return;
2093         }
2094
2095         size = fdt_totalsize(info->dtb_begin);
2096         if (size != data_size) {
2097                 pr_err("dtb 'overlay_base' header totalsize != actual size");
2098                 return;
2099         }
2100
2101         info->data = dt_alloc_memory(size, roundup_pow_of_two(FDT_V17_SIZE));
2102         if (!info->data) {
2103                 pr_err("alloc for dtb 'overlay_base' failed");
2104                 return;
2105         }
2106
2107         memcpy(info->data, info->dtb_begin, size);
2108
2109         __unflatten_device_tree(info->data, NULL, &info->np_overlay,
2110                                 dt_alloc_memory, true);
2111         overlay_base_root = info->np_overlay;
2112 }
2113
2114 /*
2115  * The purpose of of_unittest_overlay_data_add is to add an
2116  * overlay in the normal fashion.  This is a test of the whole
2117  * picture, instead of testing individual elements.
2118  *
2119  * A secondary purpose is to be able to verify that the contents of
2120  * /proc/device-tree/ contains the updated structure and values from
2121  * the overlay.  That must be verified separately in user space.
2122  *
2123  * Return 0 on unexpected error.
2124  */
2125 static int __init overlay_data_add(int onum)
2126 {
2127         struct overlay_info *info;
2128         int k;
2129         int ret;
2130         u32 size;
2131         u32 size_from_header;
2132
2133         for (k = 0, info = overlays; info; info++, k++) {
2134                 if (k == onum)
2135                         break;
2136         }
2137         if (onum > k)
2138                 return 0;
2139
2140         size = info->dtb_end - info->dtb_begin;
2141         if (!size) {
2142                 pr_err("no overlay to attach, %d\n", onum);
2143                 ret = 0;
2144         }
2145
2146         size_from_header = fdt_totalsize(info->dtb_begin);
2147         if (size_from_header != size) {
2148                 pr_err("overlay header totalsize != actual size, %d", onum);
2149                 return 0;
2150         }
2151
2152         /*
2153          * Must create permanent copy of FDT because of_fdt_unflatten_tree()
2154          * will create pointers to the passed in FDT in the EDT.
2155          */
2156         info->data = kmemdup(info->dtb_begin, size, GFP_KERNEL);
2157         if (!info->data) {
2158                 pr_err("unable to allocate memory for data, %d\n", onum);
2159                 return 0;
2160         }
2161
2162         of_fdt_unflatten_tree(info->data, NULL, &info->np_overlay);
2163         if (!info->np_overlay) {
2164                 pr_err("unable to unflatten overlay, %d\n", onum);
2165                 ret = 0;
2166                 goto out_free_data;
2167         }
2168
2169         info->overlay_id = 0;
2170         ret = of_overlay_apply(info->np_overlay, &info->overlay_id);
2171         if (ret < 0) {
2172                 pr_err("of_overlay_apply() (ret=%d), %d\n", ret, onum);
2173                 goto out_free_np_overlay;
2174         }
2175
2176         pr_debug("__dtb_overlay_begin applied, overlay id %d\n", ret);
2177
2178         goto out;
2179
2180 out_free_np_overlay:
2181         /*
2182          * info->np_overlay is the unflattened device tree
2183          * It has not been spliced into the live tree.
2184          */
2185
2186         /* todo: function to free unflattened device tree */
2187
2188 out_free_data:
2189         kfree(info->data);
2190
2191 out:
2192         return (ret == info->expected_result);
2193 }
2194
2195 /*
2196  * The purpose of of_unittest_overlay_high_level is to add an overlay
2197  * in the normal fashion.  This is a test of the whole picture,
2198  * instead of individual elements.
2199  *
2200  * The first part of the function is _not_ normal overlay usage; it is
2201  * finishing splicing the base overlay device tree into the live tree.
2202  */
2203 static __init void of_unittest_overlay_high_level(void)
2204 {
2205         struct device_node *last_sibling;
2206         struct device_node *np;
2207         struct device_node *of_symbols;
2208         struct device_node *overlay_base_symbols;
2209         struct device_node **pprev;
2210         struct property *prop;
2211         int ret;
2212
2213         if (!overlay_base_root) {
2214                 unittest(0, "overlay_base_root not initialized\n");
2215                 return;
2216         }
2217
2218         /*
2219          * Could not fixup phandles in unittest_unflatten_overlay_base()
2220          * because kmalloc() was not yet available.
2221          */
2222         of_overlay_mutex_lock();
2223         of_resolve_phandles(overlay_base_root);
2224         of_overlay_mutex_unlock();
2225
2226
2227         /*
2228          * do not allow overlay_base to duplicate any node already in
2229          * tree, this greatly simplifies the code
2230          */
2231
2232         /*
2233          * remove overlay_base_root node "__local_fixups", after
2234          * being used by of_resolve_phandles()
2235          */
2236         pprev = &overlay_base_root->child;
2237         for (np = overlay_base_root->child; np; np = np->sibling) {
2238                 if (!of_node_cmp(np->name, "__local_fixups__")) {
2239                         *pprev = np->sibling;
2240                         break;
2241                 }
2242                 pprev = &np->sibling;
2243         }
2244
2245         /* remove overlay_base_root node "__symbols__" if in live tree */
2246         of_symbols = of_get_child_by_name(of_root, "__symbols__");
2247         if (of_symbols) {
2248                 /* will have to graft properties from node into live tree */
2249                 pprev = &overlay_base_root->child;
2250                 for (np = overlay_base_root->child; np; np = np->sibling) {
2251                         if (!of_node_cmp(np->name, "__symbols__")) {
2252                                 overlay_base_symbols = np;
2253                                 *pprev = np->sibling;
2254                                 break;
2255                         }
2256                         pprev = &np->sibling;
2257                 }
2258         }
2259
2260         for (np = overlay_base_root->child; np; np = np->sibling) {
2261                 if (of_get_child_by_name(of_root, np->name)) {
2262                         unittest(0, "illegal node name in overlay_base %s",
2263                                 np->name);
2264                         return;
2265                 }
2266         }
2267
2268         /*
2269          * overlay 'overlay_base' is not allowed to have root
2270          * properties, so only need to splice nodes into main device tree.
2271          *
2272          * root node of *overlay_base_root will not be freed, it is lost
2273          * memory.
2274          */
2275
2276         for (np = overlay_base_root->child; np; np = np->sibling)
2277                 np->parent = of_root;
2278
2279         mutex_lock(&of_mutex);
2280
2281         for (last_sibling = np = of_root->child; np; np = np->sibling)
2282                 last_sibling = np;
2283
2284         if (last_sibling)
2285                 last_sibling->sibling = overlay_base_root->child;
2286         else
2287                 of_root->child = overlay_base_root->child;
2288
2289         for_each_of_allnodes_from(overlay_base_root, np)
2290                 __of_attach_node_sysfs(np);
2291
2292         if (of_symbols) {
2293                 for_each_property_of_node(overlay_base_symbols, prop) {
2294                         ret = __of_add_property(of_symbols, prop);
2295                         if (ret) {
2296                                 unittest(0,
2297                                          "duplicate property '%s' in overlay_base node __symbols__",
2298                                          prop->name);
2299                                 goto err_unlock;
2300                         }
2301                         ret = __of_add_property_sysfs(of_symbols, prop);
2302                         if (ret) {
2303                                 unittest(0,
2304                                          "unable to add property '%s' in overlay_base node __symbols__ to sysfs",
2305                                          prop->name);
2306                                 goto err_unlock;
2307                         }
2308                 }
2309         }
2310
2311         mutex_unlock(&of_mutex);
2312
2313
2314         /* now do the normal overlay usage test */
2315
2316         unittest(overlay_data_add(1),
2317                  "Adding overlay 'overlay' failed\n");
2318
2319         unittest(overlay_data_add(2),
2320                  "Adding overlay 'overlay_bad_phandle' failed\n");
2321
2322         unittest(overlay_data_add(3),
2323                  "Adding overlay 'overlay_bad_symbol' failed\n");
2324
2325         return;
2326
2327 err_unlock:
2328         mutex_unlock(&of_mutex);
2329 }
2330
2331 #else
2332
2333 static inline __init void of_unittest_overlay_high_level(void) {}
2334
2335 #endif
2336
2337 static int __init of_unittest(void)
2338 {
2339         struct device_node *np;
2340         int res;
2341
2342         /* adding data for unittest */
2343         res = unittest_data_add();
2344         if (res)
2345                 return res;
2346         if (!of_aliases)
2347                 of_aliases = of_find_node_by_path("/aliases");
2348
2349         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
2350         if (!np) {
2351                 pr_info("No testcase data in device tree; not running tests\n");
2352                 return 0;
2353         }
2354         of_node_put(np);
2355
2356         pr_info("start of unittest - you will see error messages\n");
2357         of_unittest_check_tree_linkage();
2358         of_unittest_check_phandles();
2359         of_unittest_find_node_by_name();
2360         of_unittest_dynamic();
2361         of_unittest_parse_phandle_with_args();
2362         of_unittest_printf();
2363         of_unittest_property_string();
2364         of_unittest_property_copy();
2365         of_unittest_changeset();
2366         of_unittest_parse_interrupts();
2367         of_unittest_parse_interrupts_extended();
2368         of_unittest_match_node();
2369         of_unittest_platform_populate();
2370         of_unittest_overlay();
2371
2372         /* Double check linkage after removing testcase data */
2373         of_unittest_check_tree_linkage();
2374
2375         of_unittest_overlay_high_level();
2376
2377         pr_info("end of unittest - %i passed, %i failed\n",
2378                 unittest_results.passed, unittest_results.failed);
2379
2380         return 0;
2381 }
2382 late_initcall(of_unittest);