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