drivers/of/unittest.c

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