drivers/of/unittest.c

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