1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2007. 4 */ 5 6 #include "dtc.h" 7 #include "srcpos.h" 8 9 #ifdef TRACE_CHECKS 10 #define TRACE(c, ...) \ 11 do { \ 12 fprintf(stderr, "=== %s: ", (c)->name); \ 13 fprintf(stderr, __VA_ARGS__); \ 14 fprintf(stderr, "\n"); \ 15 } while (0) 16 #else 17 #define TRACE(c, fmt, ...) do { } while (0) 18 #endif 19 20 enum checkstatus { 21 UNCHECKED = 0, 22 PREREQ, 23 PASSED, 24 FAILED, 25 }; 26 27 struct check; 28 29 typedef void (*check_fn)(struct check *c, struct dt_info *dti, struct node *node); 30 31 struct check { 32 const char *name; 33 check_fn fn; 34 const void *data; 35 bool warn, error; 36 enum checkstatus status; 37 bool inprogress; 38 int num_prereqs; 39 struct check **prereq; 40 }; 41 42 #define CHECK_ENTRY(nm_, fn_, d_, w_, e_, ...) \ 43 static struct check *nm_##_prereqs[] = { __VA_ARGS__ }; \ 44 static struct check nm_ = { \ 45 .name = #nm_, \ 46 .fn = (fn_), \ 47 .data = (d_), \ 48 .warn = (w_), \ 49 .error = (e_), \ 50 .status = UNCHECKED, \ 51 .num_prereqs = ARRAY_SIZE(nm_##_prereqs), \ 52 .prereq = nm_##_prereqs, \ 53 }; 54 #define WARNING(nm_, fn_, d_, ...) \ 55 CHECK_ENTRY(nm_, fn_, d_, true, false, __VA_ARGS__) 56 #define ERROR(nm_, fn_, d_, ...) \ 57 CHECK_ENTRY(nm_, fn_, d_, false, true, __VA_ARGS__) 58 #define CHECK(nm_, fn_, d_, ...) \ 59 CHECK_ENTRY(nm_, fn_, d_, false, false, __VA_ARGS__) 60 61 static inline void PRINTF(5, 6) check_msg(struct check *c, struct dt_info *dti, 62 struct node *node, 63 struct property *prop, 64 const char *fmt, ...) 65 { 66 va_list ap; 67 char *str = NULL; 68 struct srcpos *pos = NULL; 69 char *file_str; 70 71 if (!(c->warn && (quiet < 1)) && !(c->error && (quiet < 2))) 72 return; 73 74 if (prop && prop->srcpos) 75 pos = prop->srcpos; 76 else if (node && node->srcpos) 77 pos = node->srcpos; 78 79 if (pos) { 80 file_str = srcpos_string(pos); 81 xasprintf(&str, "%s", file_str); 82 free(file_str); 83 } else if (streq(dti->outname, "-")) { 84 xasprintf(&str, "<stdout>"); 85 } else { 86 xasprintf(&str, "%s", dti->outname); 87 } 88 89 xasprintf_append(&str, ": %s (%s): ", 90 (c->error) ? "ERROR" : "Warning", c->name); 91 92 if (node) { 93 if (prop) 94 xasprintf_append(&str, "%s:%s: ", node->fullpath, prop->name); 95 else 96 xasprintf_append(&str, "%s: ", node->fullpath); 97 } 98 99 va_start(ap, fmt); 100 xavsprintf_append(&str, fmt, ap); 101 va_end(ap); 102 103 xasprintf_append(&str, "\n"); 104 105 if (!prop && pos) { 106 pos = node->srcpos; 107 while (pos->next) { 108 pos = pos->next; 109 110 file_str = srcpos_string(pos); 111 xasprintf_append(&str, " also defined at %s\n", file_str); 112 free(file_str); 113 } 114 } 115 116 fputs(str, stderr); 117 free(str); 118 } 119 120 #define FAIL(c, dti, node, ...) \ 121 do { \ 122 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \ 123 (c)->status = FAILED; \ 124 check_msg((c), dti, node, NULL, __VA_ARGS__); \ 125 } while (0) 126 127 #define FAIL_PROP(c, dti, node, prop, ...) \ 128 do { \ 129 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \ 130 (c)->status = FAILED; \ 131 check_msg((c), dti, node, prop, __VA_ARGS__); \ 132 } while (0) 133 134 135 static void check_nodes_props(struct check *c, struct dt_info *dti, struct node *node) 136 { 137 struct node *child; 138 139 TRACE(c, "%s", node->fullpath); 140 if (c->fn) 141 c->fn(c, dti, node); 142 143 for_each_child(node, child) 144 check_nodes_props(c, dti, child); 145 } 146 147 static bool is_multiple_of(int multiple, int divisor) 148 { 149 if (divisor == 0) 150 return multiple == 0; 151 else 152 return (multiple % divisor) == 0; 153 } 154 155 static bool run_check(struct check *c, struct dt_info *dti) 156 { 157 struct node *dt = dti->dt; 158 bool error = false; 159 int i; 160 161 assert(!c->inprogress); 162 163 if (c->status != UNCHECKED) 164 goto out; 165 166 c->inprogress = true; 167 168 for (i = 0; i < c->num_prereqs; i++) { 169 struct check *prq = c->prereq[i]; 170 error = error || run_check(prq, dti); 171 if (prq->status != PASSED) { 172 c->status = PREREQ; 173 check_msg(c, dti, NULL, NULL, "Failed prerequisite '%s'", 174 c->prereq[i]->name); 175 } 176 } 177 178 if (c->status != UNCHECKED) 179 goto out; 180 181 check_nodes_props(c, dti, dt); 182 183 if (c->status == UNCHECKED) 184 c->status = PASSED; 185 186 TRACE(c, "\tCompleted, status %d", c->status); 187 188 out: 189 c->inprogress = false; 190 if ((c->status != PASSED) && (c->error)) 191 error = true; 192 return error; 193 } 194 195 /* 196 * Utility check functions 197 */ 198 199 /* A check which always fails, for testing purposes only */ 200 static inline void check_always_fail(struct check *c, struct dt_info *dti, 201 struct node *node) 202 { 203 FAIL(c, dti, node, "always_fail check"); 204 } 205 CHECK(always_fail, check_always_fail, NULL); 206 207 static void check_is_string(struct check *c, struct dt_info *dti, 208 struct node *node) 209 { 210 struct property *prop; 211 const char *propname = c->data; 212 213 prop = get_property(node, propname); 214 if (!prop) 215 return; /* Not present, assumed ok */ 216 217 if (!data_is_one_string(prop->val)) 218 FAIL_PROP(c, dti, node, prop, "property is not a string"); 219 } 220 #define WARNING_IF_NOT_STRING(nm, propname) \ 221 WARNING(nm, check_is_string, (propname)) 222 #define ERROR_IF_NOT_STRING(nm, propname) \ 223 ERROR(nm, check_is_string, (propname)) 224 225 static void check_is_string_list(struct check *c, struct dt_info *dti, 226 struct node *node) 227 { 228 int rem, l; 229 struct property *prop; 230 const char *propname = c->data; 231 char *str; 232 233 prop = get_property(node, propname); 234 if (!prop) 235 return; /* Not present, assumed ok */ 236 237 str = prop->val.val; 238 rem = prop->val.len; 239 while (rem > 0) { 240 l = strnlen(str, rem); 241 if (l == rem) { 242 FAIL_PROP(c, dti, node, prop, "property is not a string list"); 243 break; 244 } 245 rem -= l + 1; 246 str += l + 1; 247 } 248 } 249 #define WARNING_IF_NOT_STRING_LIST(nm, propname) \ 250 WARNING(nm, check_is_string_list, (propname)) 251 #define ERROR_IF_NOT_STRING_LIST(nm, propname) \ 252 ERROR(nm, check_is_string_list, (propname)) 253 254 static void check_is_cell(struct check *c, struct dt_info *dti, 255 struct node *node) 256 { 257 struct property *prop; 258 const char *propname = c->data; 259 260 prop = get_property(node, propname); 261 if (!prop) 262 return; /* Not present, assumed ok */ 263 264 if (prop->val.len != sizeof(cell_t)) 265 FAIL_PROP(c, dti, node, prop, "property is not a single cell"); 266 } 267 #define WARNING_IF_NOT_CELL(nm, propname) \ 268 WARNING(nm, check_is_cell, (propname)) 269 #define ERROR_IF_NOT_CELL(nm, propname) \ 270 ERROR(nm, check_is_cell, (propname)) 271 272 /* 273 * Structural check functions 274 */ 275 276 static void check_duplicate_node_names(struct check *c, struct dt_info *dti, 277 struct node *node) 278 { 279 struct node *child, *child2; 280 281 for_each_child(node, child) 282 for (child2 = child->next_sibling; 283 child2; 284 child2 = child2->next_sibling) 285 if (streq(child->name, child2->name)) 286 FAIL(c, dti, child2, "Duplicate node name"); 287 } 288 ERROR(duplicate_node_names, check_duplicate_node_names, NULL); 289 290 static void check_duplicate_property_names(struct check *c, struct dt_info *dti, 291 struct node *node) 292 { 293 struct property *prop, *prop2; 294 295 for_each_property(node, prop) { 296 for (prop2 = prop->next; prop2; prop2 = prop2->next) { 297 if (prop2->deleted) 298 continue; 299 if (streq(prop->name, prop2->name)) 300 FAIL_PROP(c, dti, node, prop, "Duplicate property name"); 301 } 302 } 303 } 304 ERROR(duplicate_property_names, check_duplicate_property_names, NULL); 305 306 #define LOWERCASE "abcdefghijklmnopqrstuvwxyz" 307 #define UPPERCASE "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 308 #define DIGITS "0123456789" 309 #define NODECHARS LOWERCASE UPPERCASE DIGITS ",._+-@" 310 #define PROPCHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-" 311 #define PROPNODECHARSSTRICT LOWERCASE UPPERCASE DIGITS ",-" 312 313 static void check_node_name_chars(struct check *c, struct dt_info *dti, 314 struct node *node) 315 { 316 size_t n = strspn(node->name, c->data); 317 318 if (n < strlen(node->name)) 319 FAIL(c, dti, node, "Bad character '%c' in node name", 320 node->name[n]); 321 } 322 ERROR(node_name_chars, check_node_name_chars, NODECHARS); 323 324 static void check_node_name_chars_strict(struct check *c, struct dt_info *dti, 325 struct node *node) 326 { 327 int n = strspn(node->name, c->data); 328 329 if (n < node->basenamelen) 330 FAIL(c, dti, node, "Character '%c' not recommended in node name", 331 node->name[n]); 332 } 333 CHECK(node_name_chars_strict, check_node_name_chars_strict, PROPNODECHARSSTRICT); 334 335 static void check_node_name_format(struct check *c, struct dt_info *dti, 336 struct node *node) 337 { 338 if (strchr(get_unitname(node), '@')) 339 FAIL(c, dti, node, "multiple '@' characters in node name"); 340 } 341 ERROR(node_name_format, check_node_name_format, NULL, &node_name_chars); 342 343 static void check_node_name_vs_property_name(struct check *c, 344 struct dt_info *dti, 345 struct node *node) 346 { 347 if (!node->parent) 348 return; 349 350 if (get_property(node->parent, node->name)) { 351 FAIL(c, dti, node, "node name and property name conflict"); 352 } 353 } 354 WARNING(node_name_vs_property_name, check_node_name_vs_property_name, 355 NULL, &node_name_chars); 356 357 static void check_unit_address_vs_reg(struct check *c, struct dt_info *dti, 358 struct node *node) 359 { 360 const char *unitname = get_unitname(node); 361 struct property *prop = get_property(node, "reg"); 362 363 if (get_subnode(node, "__overlay__")) { 364 /* HACK: Overlay fragments are a special case */ 365 return; 366 } 367 368 if (!prop) { 369 prop = get_property(node, "ranges"); 370 if (prop && !prop->val.len) 371 prop = NULL; 372 } 373 374 if (prop) { 375 if (!unitname[0]) 376 FAIL(c, dti, node, "node has a reg or ranges property, but no unit name"); 377 } else { 378 if (unitname[0]) 379 FAIL(c, dti, node, "node has a unit name, but no reg or ranges property"); 380 } 381 } 382 WARNING(unit_address_vs_reg, check_unit_address_vs_reg, NULL); 383 384 static void check_property_name_chars(struct check *c, struct dt_info *dti, 385 struct node *node) 386 { 387 struct property *prop; 388 389 for_each_property(node, prop) { 390 size_t n = strspn(prop->name, c->data); 391 392 if (n < strlen(prop->name)) 393 FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name", 394 prop->name[n]); 395 } 396 } 397 ERROR(property_name_chars, check_property_name_chars, PROPCHARS); 398 399 static void check_property_name_chars_strict(struct check *c, 400 struct dt_info *dti, 401 struct node *node) 402 { 403 struct property *prop; 404 405 for_each_property(node, prop) { 406 const char *name = prop->name; 407 size_t n = strspn(name, c->data); 408 409 if (n == strlen(prop->name)) 410 continue; 411 412 /* Certain names are whitelisted */ 413 if (streq(name, "device_type")) 414 continue; 415 416 /* 417 * # is only allowed at the beginning of property names not counting 418 * the vendor prefix. 419 */ 420 if (name[n] == '#' && ((n == 0) || (name[n-1] == ','))) { 421 name += n + 1; 422 n = strspn(name, c->data); 423 } 424 if (n < strlen(name)) 425 FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name", 426 name[n]); 427 } 428 } 429 CHECK(property_name_chars_strict, check_property_name_chars_strict, PROPNODECHARSSTRICT); 430 431 #define DESCLABEL_FMT "%s%s%s%s%s" 432 #define DESCLABEL_ARGS(node,prop,mark) \ 433 ((mark) ? "value of " : ""), \ 434 ((prop) ? "'" : ""), \ 435 ((prop) ? (prop)->name : ""), \ 436 ((prop) ? "' in " : ""), (node)->fullpath 437 438 static void check_duplicate_label(struct check *c, struct dt_info *dti, 439 const char *label, struct node *node, 440 struct property *prop, struct marker *mark) 441 { 442 struct node *dt = dti->dt; 443 struct node *othernode = NULL; 444 struct property *otherprop = NULL; 445 struct marker *othermark = NULL; 446 447 othernode = get_node_by_label(dt, label); 448 449 if (!othernode) 450 otherprop = get_property_by_label(dt, label, &othernode); 451 if (!othernode) 452 othermark = get_marker_label(dt, label, &othernode, 453 &otherprop); 454 455 if (!othernode) 456 return; 457 458 if ((othernode != node) || (otherprop != prop) || (othermark != mark)) 459 FAIL(c, dti, node, "Duplicate label '%s' on " DESCLABEL_FMT 460 " and " DESCLABEL_FMT, 461 label, DESCLABEL_ARGS(node, prop, mark), 462 DESCLABEL_ARGS(othernode, otherprop, othermark)); 463 } 464 465 static void check_duplicate_label_node(struct check *c, struct dt_info *dti, 466 struct node *node) 467 { 468 struct label *l; 469 struct property *prop; 470 471 for_each_label(node->labels, l) 472 check_duplicate_label(c, dti, l->label, node, NULL, NULL); 473 474 for_each_property(node, prop) { 475 struct marker *m = prop->val.markers; 476 477 for_each_label(prop->labels, l) 478 check_duplicate_label(c, dti, l->label, node, prop, NULL); 479 480 for_each_marker_of_type(m, LABEL) 481 check_duplicate_label(c, dti, m->ref, node, prop, m); 482 } 483 } 484 ERROR(duplicate_label, check_duplicate_label_node, NULL); 485 486 static cell_t check_phandle_prop(struct check *c, struct dt_info *dti, 487 struct node *node, const char *propname) 488 { 489 struct node *root = dti->dt; 490 struct property *prop; 491 struct marker *m; 492 cell_t phandle; 493 494 prop = get_property(node, propname); 495 if (!prop) 496 return 0; 497 498 if (prop->val.len != sizeof(cell_t)) { 499 FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property", 500 prop->val.len, prop->name); 501 return 0; 502 } 503 504 m = prop->val.markers; 505 for_each_marker_of_type(m, REF_PHANDLE) { 506 assert(m->offset == 0); 507 if (node != get_node_by_ref(root, m->ref)) 508 /* "Set this node's phandle equal to some 509 * other node's phandle". That's nonsensical 510 * by construction. */ { 511 FAIL(c, dti, node, "%s is a reference to another node", 512 prop->name); 513 } 514 /* But setting this node's phandle equal to its own 515 * phandle is allowed - that means allocate a unique 516 * phandle for this node, even if it's not otherwise 517 * referenced. The value will be filled in later, so 518 * we treat it as having no phandle data for now. */ 519 return 0; 520 } 521 522 phandle = propval_cell(prop); 523 524 if (!phandle_is_valid(phandle)) { 525 FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property", 526 phandle, prop->name); 527 return 0; 528 } 529 530 return phandle; 531 } 532 533 static void check_explicit_phandles(struct check *c, struct dt_info *dti, 534 struct node *node) 535 { 536 struct node *root = dti->dt; 537 struct node *other; 538 cell_t phandle, linux_phandle; 539 540 /* Nothing should have assigned phandles yet */ 541 assert(!node->phandle); 542 543 phandle = check_phandle_prop(c, dti, node, "phandle"); 544 545 linux_phandle = check_phandle_prop(c, dti, node, "linux,phandle"); 546 547 if (!phandle && !linux_phandle) 548 /* No valid phandles; nothing further to check */ 549 return; 550 551 if (linux_phandle && phandle && (phandle != linux_phandle)) 552 FAIL(c, dti, node, "mismatching 'phandle' and 'linux,phandle'" 553 " properties"); 554 555 if (linux_phandle && !phandle) 556 phandle = linux_phandle; 557 558 other = get_node_by_phandle(root, phandle); 559 if (other && (other != node)) { 560 FAIL(c, dti, node, "duplicated phandle 0x%x (seen before at %s)", 561 phandle, other->fullpath); 562 return; 563 } 564 565 node->phandle = phandle; 566 } 567 ERROR(explicit_phandles, check_explicit_phandles, NULL); 568 569 static void check_name_properties(struct check *c, struct dt_info *dti, 570 struct node *node) 571 { 572 struct property **pp, *prop = NULL; 573 574 for (pp = &node->proplist; *pp; pp = &((*pp)->next)) 575 if (streq((*pp)->name, "name")) { 576 prop = *pp; 577 break; 578 } 579 580 if (!prop) 581 return; /* No name property, that's fine */ 582 583 if ((prop->val.len != node->basenamelen + 1U) 584 || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) { 585 FAIL(c, dti, node, "\"name\" property is incorrect (\"%s\" instead" 586 " of base node name)", prop->val.val); 587 } else { 588 /* The name property is correct, and therefore redundant. 589 * Delete it */ 590 *pp = prop->next; 591 free(prop->name); 592 data_free(prop->val); 593 free(prop); 594 } 595 } 596 ERROR_IF_NOT_STRING(name_is_string, "name"); 597 ERROR(name_properties, check_name_properties, NULL, &name_is_string); 598 599 /* 600 * Reference fixup functions 601 */ 602 603 static void fixup_phandle_references(struct check *c, struct dt_info *dti, 604 struct node *node) 605 { 606 struct node *dt = dti->dt; 607 struct property *prop; 608 609 for_each_property(node, prop) { 610 struct marker *m = prop->val.markers; 611 struct node *refnode; 612 cell_t phandle; 613 614 for_each_marker_of_type(m, REF_PHANDLE) { 615 assert(m->offset + sizeof(cell_t) <= prop->val.len); 616 617 refnode = get_node_by_ref(dt, m->ref); 618 if (! refnode) { 619 if (!(dti->dtsflags & DTSF_PLUGIN)) 620 FAIL(c, dti, node, "Reference to non-existent node or " 621 "label \"%s\"\n", m->ref); 622 else /* mark the entry as unresolved */ 623 *((fdt32_t *)(prop->val.val + m->offset)) = 624 cpu_to_fdt32(0xffffffff); 625 continue; 626 } 627 628 phandle = get_node_phandle(dt, refnode); 629 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle); 630 631 reference_node(refnode); 632 } 633 } 634 } 635 ERROR(phandle_references, fixup_phandle_references, NULL, 636 &duplicate_node_names, &explicit_phandles); 637 638 static void fixup_path_references(struct check *c, struct dt_info *dti, 639 struct node *node) 640 { 641 struct node *dt = dti->dt; 642 struct property *prop; 643 644 for_each_property(node, prop) { 645 struct marker *m = prop->val.markers; 646 struct node *refnode; 647 char *path; 648 649 for_each_marker_of_type(m, REF_PATH) { 650 assert(m->offset <= prop->val.len); 651 652 refnode = get_node_by_ref(dt, m->ref); 653 if (!refnode) { 654 FAIL(c, dti, node, "Reference to non-existent node or label \"%s\"\n", 655 m->ref); 656 continue; 657 } 658 659 path = refnode->fullpath; 660 prop->val = data_insert_at_marker(prop->val, m, path, 661 strlen(path) + 1); 662 663 reference_node(refnode); 664 } 665 } 666 } 667 ERROR(path_references, fixup_path_references, NULL, &duplicate_node_names); 668 669 static void fixup_omit_unused_nodes(struct check *c, struct dt_info *dti, 670 struct node *node) 671 { 672 if (generate_symbols && node->labels) 673 return; 674 if (node->omit_if_unused && !node->is_referenced) 675 delete_node(node); 676 } 677 ERROR(omit_unused_nodes, fixup_omit_unused_nodes, NULL, &phandle_references, &path_references); 678 679 /* 680 * Semantic checks 681 */ 682 WARNING_IF_NOT_CELL(address_cells_is_cell, "#address-cells"); 683 WARNING_IF_NOT_CELL(size_cells_is_cell, "#size-cells"); 684 685 WARNING_IF_NOT_STRING(device_type_is_string, "device_type"); 686 WARNING_IF_NOT_STRING(model_is_string, "model"); 687 WARNING_IF_NOT_STRING(status_is_string, "status"); 688 WARNING_IF_NOT_STRING(label_is_string, "label"); 689 690 WARNING_IF_NOT_STRING_LIST(compatible_is_string_list, "compatible"); 691 692 static void check_names_is_string_list(struct check *c, struct dt_info *dti, 693 struct node *node) 694 { 695 struct property *prop; 696 697 for_each_property(node, prop) { 698 if (!strends(prop->name, "-names")) 699 continue; 700 701 c->data = prop->name; 702 check_is_string_list(c, dti, node); 703 } 704 } 705 WARNING(names_is_string_list, check_names_is_string_list, NULL); 706 707 static void check_alias_paths(struct check *c, struct dt_info *dti, 708 struct node *node) 709 { 710 struct property *prop; 711 712 if (!streq(node->name, "aliases")) 713 return; 714 715 for_each_property(node, prop) { 716 if (streq(prop->name, "phandle") 717 || streq(prop->name, "linux,phandle")) { 718 continue; 719 } 720 721 if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) { 722 FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)", 723 prop->val.val); 724 continue; 725 } 726 if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name)) 727 FAIL(c, dti, node, "aliases property name must include only lowercase and '-'"); 728 } 729 } 730 WARNING(alias_paths, check_alias_paths, NULL); 731 732 static void fixup_addr_size_cells(struct check *c, struct dt_info *dti, 733 struct node *node) 734 { 735 struct property *prop; 736 737 node->addr_cells = -1; 738 node->size_cells = -1; 739 740 prop = get_property(node, "#address-cells"); 741 if (prop) 742 node->addr_cells = propval_cell(prop); 743 744 prop = get_property(node, "#size-cells"); 745 if (prop) 746 node->size_cells = propval_cell(prop); 747 } 748 WARNING(addr_size_cells, fixup_addr_size_cells, NULL, 749 &address_cells_is_cell, &size_cells_is_cell); 750 751 #define node_addr_cells(n) \ 752 (((n)->addr_cells == -1) ? 2 : (n)->addr_cells) 753 #define node_size_cells(n) \ 754 (((n)->size_cells == -1) ? 1 : (n)->size_cells) 755 756 static void check_reg_format(struct check *c, struct dt_info *dti, 757 struct node *node) 758 { 759 struct property *prop; 760 int addr_cells, size_cells, entrylen; 761 762 prop = get_property(node, "reg"); 763 if (!prop) 764 return; /* No "reg", that's fine */ 765 766 if (!node->parent) { 767 FAIL(c, dti, node, "Root node has a \"reg\" property"); 768 return; 769 } 770 771 if (prop->val.len == 0) 772 FAIL_PROP(c, dti, node, prop, "property is empty"); 773 774 addr_cells = node_addr_cells(node->parent); 775 size_cells = node_size_cells(node->parent); 776 entrylen = (addr_cells + size_cells) * sizeof(cell_t); 777 778 if (!is_multiple_of(prop->val.len, entrylen)) 779 FAIL_PROP(c, dti, node, prop, "property has invalid length (%d bytes) " 780 "(#address-cells == %d, #size-cells == %d)", 781 prop->val.len, addr_cells, size_cells); 782 } 783 WARNING(reg_format, check_reg_format, NULL, &addr_size_cells); 784 785 static void check_ranges_format(struct check *c, struct dt_info *dti, 786 struct node *node) 787 { 788 struct property *prop; 789 int c_addr_cells, p_addr_cells, c_size_cells, p_size_cells, entrylen; 790 const char *ranges = c->data; 791 792 prop = get_property(node, ranges); 793 if (!prop) 794 return; 795 796 if (!node->parent) { 797 FAIL_PROP(c, dti, node, prop, "Root node has a \"%s\" property", 798 ranges); 799 return; 800 } 801 802 p_addr_cells = node_addr_cells(node->parent); 803 p_size_cells = node_size_cells(node->parent); 804 c_addr_cells = node_addr_cells(node); 805 c_size_cells = node_size_cells(node); 806 entrylen = (p_addr_cells + c_addr_cells + c_size_cells) * sizeof(cell_t); 807 808 if (prop->val.len == 0) { 809 if (p_addr_cells != c_addr_cells) 810 FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its " 811 "#address-cells (%d) differs from %s (%d)", 812 ranges, c_addr_cells, node->parent->fullpath, 813 p_addr_cells); 814 if (p_size_cells != c_size_cells) 815 FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its " 816 "#size-cells (%d) differs from %s (%d)", 817 ranges, c_size_cells, node->parent->fullpath, 818 p_size_cells); 819 } else if (!is_multiple_of(prop->val.len, entrylen)) { 820 FAIL_PROP(c, dti, node, prop, "\"%s\" property has invalid length (%d bytes) " 821 "(parent #address-cells == %d, child #address-cells == %d, " 822 "#size-cells == %d)", ranges, prop->val.len, 823 p_addr_cells, c_addr_cells, c_size_cells); 824 } 825 } 826 WARNING(ranges_format, check_ranges_format, "ranges", &addr_size_cells); 827 WARNING(dma_ranges_format, check_ranges_format, "dma-ranges", &addr_size_cells); 828 829 static const struct bus_type pci_bus = { 830 .name = "PCI", 831 }; 832 833 static void check_pci_bridge(struct check *c, struct dt_info *dti, struct node *node) 834 { 835 struct property *prop; 836 cell_t *cells; 837 838 prop = get_property(node, "device_type"); 839 if (!prop || !streq(prop->val.val, "pci")) 840 return; 841 842 node->bus = &pci_bus; 843 844 if (!strprefixeq(node->name, node->basenamelen, "pci") && 845 !strprefixeq(node->name, node->basenamelen, "pcie")) 846 FAIL(c, dti, node, "node name is not \"pci\" or \"pcie\""); 847 848 prop = get_property(node, "ranges"); 849 if (!prop) 850 FAIL(c, dti, node, "missing ranges for PCI bridge (or not a bridge)"); 851 852 if (node_addr_cells(node) != 3) 853 FAIL(c, dti, node, "incorrect #address-cells for PCI bridge"); 854 if (node_size_cells(node) != 2) 855 FAIL(c, dti, node, "incorrect #size-cells for PCI bridge"); 856 857 prop = get_property(node, "bus-range"); 858 if (!prop) 859 return; 860 861 if (prop->val.len != (sizeof(cell_t) * 2)) { 862 FAIL_PROP(c, dti, node, prop, "value must be 2 cells"); 863 return; 864 } 865 cells = (cell_t *)prop->val.val; 866 if (fdt32_to_cpu(cells[0]) > fdt32_to_cpu(cells[1])) 867 FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell"); 868 if (fdt32_to_cpu(cells[1]) > 0xff) 869 FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256"); 870 } 871 WARNING(pci_bridge, check_pci_bridge, NULL, 872 &device_type_is_string, &addr_size_cells); 873 874 static void check_pci_device_bus_num(struct check *c, struct dt_info *dti, struct node *node) 875 { 876 struct property *prop; 877 unsigned int bus_num, min_bus, max_bus; 878 cell_t *cells; 879 880 if (!node->parent || (node->parent->bus != &pci_bus)) 881 return; 882 883 prop = get_property(node, "reg"); 884 if (!prop) 885 return; 886 887 cells = (cell_t *)prop->val.val; 888 bus_num = (fdt32_to_cpu(cells[0]) & 0x00ff0000) >> 16; 889 890 prop = get_property(node->parent, "bus-range"); 891 if (!prop) { 892 min_bus = max_bus = 0; 893 } else { 894 cells = (cell_t *)prop->val.val; 895 min_bus = fdt32_to_cpu(cells[0]); 896 max_bus = fdt32_to_cpu(cells[1]); 897 } 898 if ((bus_num < min_bus) || (bus_num > max_bus)) 899 FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)", 900 bus_num, min_bus, max_bus); 901 } 902 WARNING(pci_device_bus_num, check_pci_device_bus_num, NULL, ®_format, &pci_bridge); 903 904 static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct node *node) 905 { 906 struct property *prop; 907 const char *unitname = get_unitname(node); 908 char unit_addr[5]; 909 unsigned int dev, func, reg; 910 cell_t *cells; 911 912 if (!node->parent || (node->parent->bus != &pci_bus)) 913 return; 914 915 prop = get_property(node, "reg"); 916 if (!prop) 917 return; 918 919 cells = (cell_t *)prop->val.val; 920 if (cells[1] || cells[2]) 921 FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0"); 922 923 reg = fdt32_to_cpu(cells[0]); 924 dev = (reg & 0xf800) >> 11; 925 func = (reg & 0x700) >> 8; 926 927 if (reg & 0xff000000) 928 FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space"); 929 if (reg & 0x000000ff) 930 FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0"); 931 932 if (func == 0) { 933 snprintf(unit_addr, sizeof(unit_addr), "%x", dev); 934 if (streq(unitname, unit_addr)) 935 return; 936 } 937 938 snprintf(unit_addr, sizeof(unit_addr), "%x,%x", dev, func); 939 if (streq(unitname, unit_addr)) 940 return; 941 942 FAIL(c, dti, node, "PCI unit address format error, expected \"%s\"", 943 unit_addr); 944 } 945 WARNING(pci_device_reg, check_pci_device_reg, NULL, ®_format, &pci_bridge); 946 947 static const struct bus_type simple_bus = { 948 .name = "simple-bus", 949 }; 950 951 static bool node_is_compatible(struct node *node, const char *compat) 952 { 953 struct property *prop; 954 const char *str, *end; 955 956 prop = get_property(node, "compatible"); 957 if (!prop) 958 return false; 959 960 for (str = prop->val.val, end = str + prop->val.len; str < end; 961 str += strnlen(str, end - str) + 1) { 962 if (streq(str, compat)) 963 return true; 964 } 965 return false; 966 } 967 968 static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node) 969 { 970 if (node_is_compatible(node, "simple-bus")) 971 node->bus = &simple_bus; 972 } 973 WARNING(simple_bus_bridge, check_simple_bus_bridge, NULL, 974 &addr_size_cells, &compatible_is_string_list); 975 976 static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct node *node) 977 { 978 struct property *prop; 979 const char *unitname = get_unitname(node); 980 char unit_addr[17]; 981 unsigned int size; 982 uint64_t reg = 0; 983 cell_t *cells = NULL; 984 985 if (!node->parent || (node->parent->bus != &simple_bus)) 986 return; 987 988 prop = get_property(node, "reg"); 989 if (prop) 990 cells = (cell_t *)prop->val.val; 991 else { 992 prop = get_property(node, "ranges"); 993 if (prop && prop->val.len) 994 /* skip of child address */ 995 cells = ((cell_t *)prop->val.val) + node_addr_cells(node); 996 } 997 998 if (!cells) { 999 if (node->parent->parent && !(node->bus == &simple_bus)) 1000 FAIL(c, dti, node, "missing or empty reg/ranges property"); 1001 return; 1002 } 1003 1004 size = node_addr_cells(node->parent); 1005 while (size--) 1006 reg = (reg << 32) | fdt32_to_cpu(*(cells++)); 1007 1008 snprintf(unit_addr, sizeof(unit_addr), "%"PRIx64, reg); 1009 if (!streq(unitname, unit_addr)) 1010 FAIL(c, dti, node, "simple-bus unit address format error, expected \"%s\"", 1011 unit_addr); 1012 } 1013 WARNING(simple_bus_reg, check_simple_bus_reg, NULL, ®_format, &simple_bus_bridge); 1014 1015 static const struct bus_type i2c_bus = { 1016 .name = "i2c-bus", 1017 }; 1018 1019 static void check_i2c_bus_bridge(struct check *c, struct dt_info *dti, struct node *node) 1020 { 1021 if (strprefixeq(node->name, node->basenamelen, "i2c-bus") || 1022 strprefixeq(node->name, node->basenamelen, "i2c-arb")) { 1023 node->bus = &i2c_bus; 1024 } else if (strprefixeq(node->name, node->basenamelen, "i2c")) { 1025 struct node *child; 1026 for_each_child(node, child) { 1027 if (strprefixeq(child->name, node->basenamelen, "i2c-bus")) 1028 return; 1029 } 1030 node->bus = &i2c_bus; 1031 } else 1032 return; 1033 1034 if (!node->children) 1035 return; 1036 1037 if (node_addr_cells(node) != 1) 1038 FAIL(c, dti, node, "incorrect #address-cells for I2C bus"); 1039 if (node_size_cells(node) != 0) 1040 FAIL(c, dti, node, "incorrect #size-cells for I2C bus"); 1041 1042 } 1043 WARNING(i2c_bus_bridge, check_i2c_bus_bridge, NULL, &addr_size_cells); 1044 1045 #define I2C_OWN_SLAVE_ADDRESS (1U << 30) 1046 #define I2C_TEN_BIT_ADDRESS (1U << 31) 1047 1048 static void check_i2c_bus_reg(struct check *c, struct dt_info *dti, struct node *node) 1049 { 1050 struct property *prop; 1051 const char *unitname = get_unitname(node); 1052 char unit_addr[17]; 1053 uint32_t reg = 0; 1054 int len; 1055 cell_t *cells = NULL; 1056 1057 if (!node->parent || (node->parent->bus != &i2c_bus)) 1058 return; 1059 1060 prop = get_property(node, "reg"); 1061 if (prop) 1062 cells = (cell_t *)prop->val.val; 1063 1064 if (!cells) { 1065 FAIL(c, dti, node, "missing or empty reg property"); 1066 return; 1067 } 1068 1069 reg = fdt32_to_cpu(*cells); 1070 /* Ignore I2C_OWN_SLAVE_ADDRESS */ 1071 reg &= ~I2C_OWN_SLAVE_ADDRESS; 1072 snprintf(unit_addr, sizeof(unit_addr), "%x", reg); 1073 if (!streq(unitname, unit_addr)) 1074 FAIL(c, dti, node, "I2C bus unit address format error, expected \"%s\"", 1075 unit_addr); 1076 1077 for (len = prop->val.len; len > 0; len -= 4) { 1078 reg = fdt32_to_cpu(*(cells++)); 1079 /* Ignore I2C_OWN_SLAVE_ADDRESS */ 1080 reg &= ~I2C_OWN_SLAVE_ADDRESS; 1081 1082 if (reg & I2C_TEN_BIT_ADDRESS) { 1083 if ((reg & ~I2C_TEN_BIT_ADDRESS) > 0x3ff) 1084 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 10-bits, got \"0x%x\"", 1085 reg); 1086 } else if (reg > 0x7f) 1087 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 7-bits, got \"0x%x\". Set I2C_TEN_BIT_ADDRESS for 10 bit addresses or fix the property", 1088 reg); 1089 } 1090 } 1091 WARNING(i2c_bus_reg, check_i2c_bus_reg, NULL, ®_format, &i2c_bus_bridge); 1092 1093 static const struct bus_type spi_bus = { 1094 .name = "spi-bus", 1095 }; 1096 1097 static void check_spi_bus_bridge(struct check *c, struct dt_info *dti, struct node *node) 1098 { 1099 int spi_addr_cells = 1; 1100 1101 if (strprefixeq(node->name, node->basenamelen, "spi")) { 1102 node->bus = &spi_bus; 1103 } else { 1104 /* Try to detect SPI buses which don't have proper node name */ 1105 struct node *child; 1106 1107 if (node_addr_cells(node) != 1 || node_size_cells(node) != 0) 1108 return; 1109 1110 for_each_child(node, child) { 1111 struct property *prop; 1112 for_each_property(child, prop) { 1113 if (strstarts(prop->name, "spi-")) { 1114 node->bus = &spi_bus; 1115 break; 1116 } 1117 } 1118 if (node->bus == &spi_bus) 1119 break; 1120 } 1121 1122 if (node->bus == &spi_bus && get_property(node, "reg")) 1123 FAIL(c, dti, node, "node name for SPI buses should be 'spi'"); 1124 } 1125 if (node->bus != &spi_bus || !node->children) 1126 return; 1127 1128 if (get_property(node, "spi-slave")) 1129 spi_addr_cells = 0; 1130 if (node_addr_cells(node) != spi_addr_cells) 1131 FAIL(c, dti, node, "incorrect #address-cells for SPI bus"); 1132 if (node_size_cells(node) != 0) 1133 FAIL(c, dti, node, "incorrect #size-cells for SPI bus"); 1134 1135 } 1136 WARNING(spi_bus_bridge, check_spi_bus_bridge, NULL, &addr_size_cells); 1137 1138 static void check_spi_bus_reg(struct check *c, struct dt_info *dti, struct node *node) 1139 { 1140 struct property *prop; 1141 const char *unitname = get_unitname(node); 1142 char unit_addr[9]; 1143 uint32_t reg = 0; 1144 cell_t *cells = NULL; 1145 1146 if (!node->parent || (node->parent->bus != &spi_bus)) 1147 return; 1148 1149 if (get_property(node->parent, "spi-slave")) 1150 return; 1151 1152 prop = get_property(node, "reg"); 1153 if (prop) 1154 cells = (cell_t *)prop->val.val; 1155 1156 if (!cells) { 1157 FAIL(c, dti, node, "missing or empty reg property"); 1158 return; 1159 } 1160 1161 reg = fdt32_to_cpu(*cells); 1162 snprintf(unit_addr, sizeof(unit_addr), "%x", reg); 1163 if (!streq(unitname, unit_addr)) 1164 FAIL(c, dti, node, "SPI bus unit address format error, expected \"%s\"", 1165 unit_addr); 1166 } 1167 WARNING(spi_bus_reg, check_spi_bus_reg, NULL, ®_format, &spi_bus_bridge); 1168 1169 static void check_unit_address_format(struct check *c, struct dt_info *dti, 1170 struct node *node) 1171 { 1172 const char *unitname = get_unitname(node); 1173 1174 if (node->parent && node->parent->bus) 1175 return; 1176 1177 if (!unitname[0]) 1178 return; 1179 1180 if (!strncmp(unitname, "0x", 2)) { 1181 FAIL(c, dti, node, "unit name should not have leading \"0x\""); 1182 /* skip over 0x for next test */ 1183 unitname += 2; 1184 } 1185 if (unitname[0] == '0' && isxdigit((unsigned char)unitname[1])) 1186 FAIL(c, dti, node, "unit name should not have leading 0s"); 1187 } 1188 WARNING(unit_address_format, check_unit_address_format, NULL, 1189 &node_name_format, &pci_bridge, &simple_bus_bridge); 1190 1191 /* 1192 * Style checks 1193 */ 1194 static void check_avoid_default_addr_size(struct check *c, struct dt_info *dti, 1195 struct node *node) 1196 { 1197 struct property *reg, *ranges; 1198 1199 if (!node->parent) 1200 return; /* Ignore root node */ 1201 1202 reg = get_property(node, "reg"); 1203 ranges = get_property(node, "ranges"); 1204 1205 if (!reg && !ranges) 1206 return; 1207 1208 if (node->parent->addr_cells == -1) 1209 FAIL(c, dti, node, "Relying on default #address-cells value"); 1210 1211 if (node->parent->size_cells == -1) 1212 FAIL(c, dti, node, "Relying on default #size-cells value"); 1213 } 1214 WARNING(avoid_default_addr_size, check_avoid_default_addr_size, NULL, 1215 &addr_size_cells); 1216 1217 static void check_avoid_unnecessary_addr_size(struct check *c, struct dt_info *dti, 1218 struct node *node) 1219 { 1220 struct property *prop; 1221 struct node *child; 1222 bool has_reg = false; 1223 1224 if (!node->parent || node->addr_cells < 0 || node->size_cells < 0) 1225 return; 1226 1227 if (get_property(node, "ranges") || get_property(node, "dma-ranges") || !node->children) 1228 return; 1229 1230 for_each_child(node, child) { 1231 prop = get_property(child, "reg"); 1232 if (prop) 1233 has_reg = true; 1234 } 1235 1236 if (!has_reg) 1237 FAIL(c, dti, node, "unnecessary #address-cells/#size-cells without \"ranges\", \"dma-ranges\" or child \"reg\" property"); 1238 } 1239 WARNING(avoid_unnecessary_addr_size, check_avoid_unnecessary_addr_size, NULL, &avoid_default_addr_size); 1240 1241 static bool node_is_disabled(struct node *node) 1242 { 1243 struct property *prop; 1244 1245 prop = get_property(node, "status"); 1246 if (prop) { 1247 char *str = prop->val.val; 1248 if (streq("disabled", str)) 1249 return true; 1250 } 1251 1252 return false; 1253 } 1254 1255 static void check_unique_unit_address_common(struct check *c, 1256 struct dt_info *dti, 1257 struct node *node, 1258 bool disable_check) 1259 { 1260 struct node *childa; 1261 1262 if (node->addr_cells < 0 || node->size_cells < 0) 1263 return; 1264 1265 if (!node->children) 1266 return; 1267 1268 for_each_child(node, childa) { 1269 struct node *childb; 1270 const char *addr_a = get_unitname(childa); 1271 1272 if (!strlen(addr_a)) 1273 continue; 1274 1275 if (disable_check && node_is_disabled(childa)) 1276 continue; 1277 1278 for_each_child(node, childb) { 1279 const char *addr_b = get_unitname(childb); 1280 if (childa == childb) 1281 break; 1282 1283 if (disable_check && node_is_disabled(childb)) 1284 continue; 1285 1286 if (streq(addr_a, addr_b)) 1287 FAIL(c, dti, childb, "duplicate unit-address (also used in node %s)", childa->fullpath); 1288 } 1289 } 1290 } 1291 1292 static void check_unique_unit_address(struct check *c, struct dt_info *dti, 1293 struct node *node) 1294 { 1295 check_unique_unit_address_common(c, dti, node, false); 1296 } 1297 WARNING(unique_unit_address, check_unique_unit_address, NULL, &avoid_default_addr_size); 1298 1299 static void check_unique_unit_address_if_enabled(struct check *c, struct dt_info *dti, 1300 struct node *node) 1301 { 1302 check_unique_unit_address_common(c, dti, node, true); 1303 } 1304 CHECK_ENTRY(unique_unit_address_if_enabled, check_unique_unit_address_if_enabled, 1305 NULL, false, false, &avoid_default_addr_size); 1306 1307 static void check_obsolete_chosen_interrupt_controller(struct check *c, 1308 struct dt_info *dti, 1309 struct node *node) 1310 { 1311 struct node *dt = dti->dt; 1312 struct node *chosen; 1313 struct property *prop; 1314 1315 if (node != dt) 1316 return; 1317 1318 1319 chosen = get_node_by_path(dt, "/chosen"); 1320 if (!chosen) 1321 return; 1322 1323 prop = get_property(chosen, "interrupt-controller"); 1324 if (prop) 1325 FAIL_PROP(c, dti, node, prop, 1326 "/chosen has obsolete \"interrupt-controller\" property"); 1327 } 1328 WARNING(obsolete_chosen_interrupt_controller, 1329 check_obsolete_chosen_interrupt_controller, NULL); 1330 1331 static void check_chosen_node_is_root(struct check *c, struct dt_info *dti, 1332 struct node *node) 1333 { 1334 if (!streq(node->name, "chosen")) 1335 return; 1336 1337 if (node->parent != dti->dt) 1338 FAIL(c, dti, node, "chosen node must be at root node"); 1339 } 1340 WARNING(chosen_node_is_root, check_chosen_node_is_root, NULL); 1341 1342 static void check_chosen_node_bootargs(struct check *c, struct dt_info *dti, 1343 struct node *node) 1344 { 1345 struct property *prop; 1346 1347 if (!streq(node->name, "chosen")) 1348 return; 1349 1350 prop = get_property(node, "bootargs"); 1351 if (!prop) 1352 return; 1353 1354 c->data = prop->name; 1355 check_is_string(c, dti, node); 1356 } 1357 WARNING(chosen_node_bootargs, check_chosen_node_bootargs, NULL); 1358 1359 static void check_chosen_node_stdout_path(struct check *c, struct dt_info *dti, 1360 struct node *node) 1361 { 1362 struct property *prop; 1363 1364 if (!streq(node->name, "chosen")) 1365 return; 1366 1367 prop = get_property(node, "stdout-path"); 1368 if (!prop) { 1369 prop = get_property(node, "linux,stdout-path"); 1370 if (!prop) 1371 return; 1372 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead"); 1373 } 1374 1375 c->data = prop->name; 1376 check_is_string(c, dti, node); 1377 } 1378 WARNING(chosen_node_stdout_path, check_chosen_node_stdout_path, NULL); 1379 1380 struct provider { 1381 const char *prop_name; 1382 const char *cell_name; 1383 bool optional; 1384 }; 1385 1386 static void check_property_phandle_args(struct check *c, 1387 struct dt_info *dti, 1388 struct node *node, 1389 struct property *prop, 1390 const struct provider *provider) 1391 { 1392 struct node *root = dti->dt; 1393 unsigned int cell, cellsize = 0; 1394 1395 if (!is_multiple_of(prop->val.len, sizeof(cell_t))) { 1396 FAIL_PROP(c, dti, node, prop, 1397 "property size (%d) is invalid, expected multiple of %zu", 1398 prop->val.len, sizeof(cell_t)); 1399 return; 1400 } 1401 1402 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) { 1403 struct node *provider_node; 1404 struct property *cellprop; 1405 cell_t phandle; 1406 unsigned int expected; 1407 1408 phandle = propval_cell_n(prop, cell); 1409 /* 1410 * Some bindings use a cell value 0 or -1 to skip over optional 1411 * entries when each index position has a specific definition. 1412 */ 1413 if (!phandle_is_valid(phandle)) { 1414 /* Give up if this is an overlay with external references */ 1415 if (dti->dtsflags & DTSF_PLUGIN) 1416 break; 1417 1418 cellsize = 0; 1419 continue; 1420 } 1421 1422 /* If we have markers, verify the current cell is a phandle */ 1423 if (prop->val.markers) { 1424 struct marker *m = prop->val.markers; 1425 for_each_marker_of_type(m, REF_PHANDLE) { 1426 if (m->offset == (cell * sizeof(cell_t))) 1427 break; 1428 } 1429 if (!m) 1430 FAIL_PROP(c, dti, node, prop, 1431 "cell %d is not a phandle reference", 1432 cell); 1433 } 1434 1435 provider_node = get_node_by_phandle(root, phandle); 1436 if (!provider_node) { 1437 FAIL_PROP(c, dti, node, prop, 1438 "Could not get phandle node for (cell %d)", 1439 cell); 1440 break; 1441 } 1442 1443 cellprop = get_property(provider_node, provider->cell_name); 1444 if (cellprop) { 1445 cellsize = propval_cell(cellprop); 1446 } else if (provider->optional) { 1447 cellsize = 0; 1448 } else { 1449 FAIL(c, dti, node, "Missing property '%s' in node %s or bad phandle (referred from %s[%d])", 1450 provider->cell_name, 1451 provider_node->fullpath, 1452 prop->name, cell); 1453 break; 1454 } 1455 1456 expected = (cell + cellsize + 1) * sizeof(cell_t); 1457 if ((expected <= cell) || prop->val.len < expected) { 1458 FAIL_PROP(c, dti, node, prop, 1459 "property size (%d) too small for cell size %u", 1460 prop->val.len, cellsize); 1461 break; 1462 } 1463 } 1464 } 1465 1466 static void check_provider_cells_property(struct check *c, 1467 struct dt_info *dti, 1468 struct node *node) 1469 { 1470 const struct provider *provider = c->data; 1471 struct property *prop; 1472 1473 prop = get_property(node, provider->prop_name); 1474 if (!prop) 1475 return; 1476 1477 check_property_phandle_args(c, dti, node, prop, provider); 1478 } 1479 #define WARNING_PROPERTY_PHANDLE_CELLS(nm, propname, cells_name, ...) \ 1480 static struct provider nm##_provider = { (propname), (cells_name), __VA_ARGS__ }; \ 1481 WARNING_IF_NOT_CELL(nm##_is_cell, cells_name); \ 1482 WARNING(nm##_property, check_provider_cells_property, &nm##_provider, &nm##_is_cell, &phandle_references); 1483 1484 WARNING_PROPERTY_PHANDLE_CELLS(clocks, "clocks", "#clock-cells"); 1485 WARNING_PROPERTY_PHANDLE_CELLS(cooling_device, "cooling-device", "#cooling-cells"); 1486 WARNING_PROPERTY_PHANDLE_CELLS(dmas, "dmas", "#dma-cells"); 1487 WARNING_PROPERTY_PHANDLE_CELLS(hwlocks, "hwlocks", "#hwlock-cells"); 1488 WARNING_PROPERTY_PHANDLE_CELLS(interrupts_extended, "interrupts-extended", "#interrupt-cells"); 1489 WARNING_PROPERTY_PHANDLE_CELLS(io_channels, "io-channels", "#io-channel-cells"); 1490 WARNING_PROPERTY_PHANDLE_CELLS(iommus, "iommus", "#iommu-cells"); 1491 WARNING_PROPERTY_PHANDLE_CELLS(mboxes, "mboxes", "#mbox-cells"); 1492 WARNING_PROPERTY_PHANDLE_CELLS(msi_parent, "msi-parent", "#msi-cells", true); 1493 WARNING_PROPERTY_PHANDLE_CELLS(mux_controls, "mux-controls", "#mux-control-cells"); 1494 WARNING_PROPERTY_PHANDLE_CELLS(phys, "phys", "#phy-cells"); 1495 WARNING_PROPERTY_PHANDLE_CELLS(power_domains, "power-domains", "#power-domain-cells"); 1496 WARNING_PROPERTY_PHANDLE_CELLS(pwms, "pwms", "#pwm-cells"); 1497 WARNING_PROPERTY_PHANDLE_CELLS(resets, "resets", "#reset-cells"); 1498 WARNING_PROPERTY_PHANDLE_CELLS(sound_dai, "sound-dai", "#sound-dai-cells"); 1499 WARNING_PROPERTY_PHANDLE_CELLS(thermal_sensors, "thermal-sensors", "#thermal-sensor-cells"); 1500 1501 static bool prop_is_gpio(struct property *prop) 1502 { 1503 /* 1504 * *-gpios and *-gpio can appear in property names, 1505 * so skip over any false matches (only one known ATM) 1506 */ 1507 if (strends(prop->name, ",nr-gpios")) 1508 return false; 1509 1510 return strends(prop->name, "-gpios") || 1511 streq(prop->name, "gpios") || 1512 strends(prop->name, "-gpio") || 1513 streq(prop->name, "gpio"); 1514 } 1515 1516 static void check_gpios_property(struct check *c, 1517 struct dt_info *dti, 1518 struct node *node) 1519 { 1520 struct property *prop; 1521 1522 /* Skip GPIO hog nodes which have 'gpios' property */ 1523 if (get_property(node, "gpio-hog")) 1524 return; 1525 1526 for_each_property(node, prop) { 1527 struct provider provider; 1528 1529 if (!prop_is_gpio(prop)) 1530 continue; 1531 1532 provider.prop_name = prop->name; 1533 provider.cell_name = "#gpio-cells"; 1534 provider.optional = false; 1535 check_property_phandle_args(c, dti, node, prop, &provider); 1536 } 1537 1538 } 1539 WARNING(gpios_property, check_gpios_property, NULL, &phandle_references); 1540 1541 static void check_deprecated_gpio_property(struct check *c, 1542 struct dt_info *dti, 1543 struct node *node) 1544 { 1545 struct property *prop; 1546 1547 for_each_property(node, prop) { 1548 if (!prop_is_gpio(prop)) 1549 continue; 1550 1551 if (!strends(prop->name, "gpio")) 1552 continue; 1553 1554 FAIL_PROP(c, dti, node, prop, 1555 "'[*-]gpio' is deprecated, use '[*-]gpios' instead"); 1556 } 1557 1558 } 1559 CHECK(deprecated_gpio_property, check_deprecated_gpio_property, NULL); 1560 1561 static bool node_is_interrupt_provider(struct node *node) 1562 { 1563 struct property *prop; 1564 1565 prop = get_property(node, "interrupt-controller"); 1566 if (prop) 1567 return true; 1568 1569 prop = get_property(node, "interrupt-map"); 1570 if (prop) 1571 return true; 1572 1573 return false; 1574 } 1575 1576 static void check_interrupt_provider(struct check *c, 1577 struct dt_info *dti, 1578 struct node *node) 1579 { 1580 struct property *prop; 1581 bool irq_provider = node_is_interrupt_provider(node); 1582 1583 prop = get_property(node, "#interrupt-cells"); 1584 if (irq_provider && !prop) { 1585 FAIL(c, dti, node, 1586 "Missing '#interrupt-cells' in interrupt provider"); 1587 return; 1588 } 1589 1590 if (!irq_provider && prop) { 1591 FAIL(c, dti, node, 1592 "'#interrupt-cells' found, but node is not an interrupt provider"); 1593 return; 1594 } 1595 } 1596 WARNING(interrupt_provider, check_interrupt_provider, NULL, &interrupts_extended_is_cell); 1597 1598 static void check_interrupt_map(struct check *c, 1599 struct dt_info *dti, 1600 struct node *node) 1601 { 1602 struct node *root = dti->dt; 1603 struct property *prop, *irq_map_prop; 1604 size_t cellsize, cell, map_cells; 1605 1606 irq_map_prop = get_property(node, "interrupt-map"); 1607 if (!irq_map_prop) 1608 return; 1609 1610 if (node->addr_cells < 0) { 1611 FAIL(c, dti, node, 1612 "Missing '#address-cells' in interrupt-map provider"); 1613 return; 1614 } 1615 cellsize = node_addr_cells(node); 1616 cellsize += propval_cell(get_property(node, "#interrupt-cells")); 1617 1618 prop = get_property(node, "interrupt-map-mask"); 1619 if (prop && (prop->val.len != (cellsize * sizeof(cell_t)))) 1620 FAIL_PROP(c, dti, node, prop, 1621 "property size (%d) is invalid, expected %zu", 1622 prop->val.len, cellsize * sizeof(cell_t)); 1623 1624 if (!is_multiple_of(irq_map_prop->val.len, sizeof(cell_t))) { 1625 FAIL_PROP(c, dti, node, irq_map_prop, 1626 "property size (%d) is invalid, expected multiple of %zu", 1627 irq_map_prop->val.len, sizeof(cell_t)); 1628 return; 1629 } 1630 1631 map_cells = irq_map_prop->val.len / sizeof(cell_t); 1632 for (cell = 0; cell < map_cells; ) { 1633 struct node *provider_node; 1634 struct property *cellprop; 1635 int phandle; 1636 size_t parent_cellsize; 1637 1638 if ((cell + cellsize) >= map_cells) { 1639 FAIL_PROP(c, dti, node, irq_map_prop, 1640 "property size (%d) too small, expected > %zu", 1641 irq_map_prop->val.len, (cell + cellsize) * sizeof(cell_t)); 1642 break; 1643 } 1644 cell += cellsize; 1645 1646 phandle = propval_cell_n(irq_map_prop, cell); 1647 if (!phandle_is_valid(phandle)) { 1648 /* Give up if this is an overlay with external references */ 1649 if (!(dti->dtsflags & DTSF_PLUGIN)) 1650 FAIL_PROP(c, dti, node, irq_map_prop, 1651 "Cell %zu is not a phandle(%d)", 1652 cell, phandle); 1653 break; 1654 } 1655 1656 provider_node = get_node_by_phandle(root, phandle); 1657 if (!provider_node) { 1658 FAIL_PROP(c, dti, node, irq_map_prop, 1659 "Could not get phandle(%d) node for (cell %zu)", 1660 phandle, cell); 1661 break; 1662 } 1663 1664 cellprop = get_property(provider_node, "#interrupt-cells"); 1665 if (cellprop) { 1666 parent_cellsize = propval_cell(cellprop); 1667 } else { 1668 FAIL(c, dti, node, "Missing property '#interrupt-cells' in node %s or bad phandle (referred from interrupt-map[%zu])", 1669 provider_node->fullpath, cell); 1670 break; 1671 } 1672 1673 cellprop = get_property(provider_node, "#address-cells"); 1674 if (cellprop) 1675 parent_cellsize += propval_cell(cellprop); 1676 1677 cell += 1 + parent_cellsize; 1678 if (cell > map_cells) 1679 FAIL_PROP(c, dti, node, irq_map_prop, 1680 "property size (%d) mismatch, expected %zu", 1681 irq_map_prop->val.len, cell * sizeof(cell_t)); 1682 } 1683 } 1684 WARNING(interrupt_map, check_interrupt_map, NULL, &phandle_references, &addr_size_cells, &interrupt_provider); 1685 1686 static void check_interrupts_property(struct check *c, 1687 struct dt_info *dti, 1688 struct node *node) 1689 { 1690 struct node *root = dti->dt; 1691 struct node *irq_node = NULL, *parent = node; 1692 struct property *irq_prop, *prop = NULL; 1693 cell_t irq_cells, phandle; 1694 1695 irq_prop = get_property(node, "interrupts"); 1696 if (!irq_prop) 1697 return; 1698 1699 if (!is_multiple_of(irq_prop->val.len, sizeof(cell_t))) 1700 FAIL_PROP(c, dti, node, irq_prop, "size (%d) is invalid, expected multiple of %zu", 1701 irq_prop->val.len, sizeof(cell_t)); 1702 1703 while (parent && !prop) { 1704 if (parent != node && node_is_interrupt_provider(parent)) { 1705 irq_node = parent; 1706 break; 1707 } 1708 1709 prop = get_property(parent, "interrupt-parent"); 1710 if (prop) { 1711 phandle = propval_cell(prop); 1712 if (!phandle_is_valid(phandle)) { 1713 /* Give up if this is an overlay with 1714 * external references */ 1715 if (dti->dtsflags & DTSF_PLUGIN) 1716 return; 1717 FAIL_PROP(c, dti, parent, prop, "Invalid phandle"); 1718 continue; 1719 } 1720 1721 irq_node = get_node_by_phandle(root, phandle); 1722 if (!irq_node) { 1723 FAIL_PROP(c, dti, parent, prop, "Bad phandle"); 1724 return; 1725 } 1726 if (!node_is_interrupt_provider(irq_node)) 1727 FAIL(c, dti, irq_node, 1728 "Missing interrupt-controller or interrupt-map property"); 1729 1730 break; 1731 } 1732 1733 parent = parent->parent; 1734 } 1735 1736 if (!irq_node) { 1737 FAIL(c, dti, node, "Missing interrupt-parent"); 1738 return; 1739 } 1740 1741 prop = get_property(irq_node, "#interrupt-cells"); 1742 if (!prop) { 1743 /* We warn about that already in another test. */ 1744 return; 1745 } 1746 1747 irq_cells = propval_cell(prop); 1748 if (!is_multiple_of(irq_prop->val.len, irq_cells * sizeof(cell_t))) { 1749 FAIL_PROP(c, dti, node, prop, 1750 "size is (%d), expected multiple of %d", 1751 irq_prop->val.len, (int)(irq_cells * sizeof(cell_t))); 1752 } 1753 } 1754 WARNING(interrupts_property, check_interrupts_property, &phandle_references); 1755 1756 static const struct bus_type graph_port_bus = { 1757 .name = "graph-port", 1758 }; 1759 1760 static const struct bus_type graph_ports_bus = { 1761 .name = "graph-ports", 1762 }; 1763 1764 static void check_graph_nodes(struct check *c, struct dt_info *dti, 1765 struct node *node) 1766 { 1767 struct node *child; 1768 1769 for_each_child(node, child) { 1770 if (!(strprefixeq(child->name, child->basenamelen, "endpoint") || 1771 get_property(child, "remote-endpoint"))) 1772 continue; 1773 1774 /* The root node cannot be a port */ 1775 if (!node->parent) { 1776 FAIL(c, dti, node, "root node contains endpoint node '%s', potentially misplaced remote-endpoint property", child->name); 1777 continue; 1778 } 1779 node->bus = &graph_port_bus; 1780 1781 /* The parent of 'port' nodes can be either 'ports' or a device */ 1782 if (!node->parent->bus && 1783 (streq(node->parent->name, "ports") || get_property(node, "reg"))) 1784 node->parent->bus = &graph_ports_bus; 1785 1786 break; 1787 } 1788 1789 } 1790 WARNING(graph_nodes, check_graph_nodes, NULL); 1791 1792 static void check_graph_reg(struct check *c, struct dt_info *dti, 1793 struct node *node) 1794 { 1795 char unit_addr[9]; 1796 const char *unitname = get_unitname(node); 1797 struct property *prop; 1798 1799 prop = get_property(node, "reg"); 1800 if (!prop || !unitname) 1801 return; 1802 1803 if (!(prop->val.val && prop->val.len == sizeof(cell_t))) { 1804 FAIL(c, dti, node, "graph node malformed 'reg' property"); 1805 return; 1806 } 1807 1808 snprintf(unit_addr, sizeof(unit_addr), "%x", propval_cell(prop)); 1809 if (!streq(unitname, unit_addr)) 1810 FAIL(c, dti, node, "graph node unit address error, expected \"%s\"", 1811 unit_addr); 1812 1813 if (node->parent->addr_cells != 1) 1814 FAIL_PROP(c, dti, node, get_property(node, "#address-cells"), 1815 "graph node '#address-cells' is %d, must be 1", 1816 node->parent->addr_cells); 1817 if (node->parent->size_cells != 0) 1818 FAIL_PROP(c, dti, node, get_property(node, "#size-cells"), 1819 "graph node '#size-cells' is %d, must be 0", 1820 node->parent->size_cells); 1821 } 1822 1823 static void check_graph_port(struct check *c, struct dt_info *dti, 1824 struct node *node) 1825 { 1826 if (node->bus != &graph_port_bus) 1827 return; 1828 1829 check_graph_reg(c, dti, node); 1830 1831 /* skip checks below for overlays */ 1832 if (dti->dtsflags & DTSF_PLUGIN) 1833 return; 1834 1835 if (!strprefixeq(node->name, node->basenamelen, "port")) 1836 FAIL(c, dti, node, "graph port node name should be 'port'"); 1837 } 1838 WARNING(graph_port, check_graph_port, NULL, &graph_nodes); 1839 1840 static struct node *get_remote_endpoint(struct check *c, struct dt_info *dti, 1841 struct node *endpoint) 1842 { 1843 cell_t phandle; 1844 struct node *node; 1845 struct property *prop; 1846 1847 prop = get_property(endpoint, "remote-endpoint"); 1848 if (!prop) 1849 return NULL; 1850 1851 phandle = propval_cell(prop); 1852 /* Give up if this is an overlay with external references */ 1853 if (!phandle_is_valid(phandle)) 1854 return NULL; 1855 1856 node = get_node_by_phandle(dti->dt, phandle); 1857 if (!node) 1858 FAIL_PROP(c, dti, endpoint, prop, "graph phandle is not valid"); 1859 1860 return node; 1861 } 1862 1863 static void check_graph_endpoint(struct check *c, struct dt_info *dti, 1864 struct node *node) 1865 { 1866 struct node *remote_node; 1867 1868 if (!node->parent || node->parent->bus != &graph_port_bus) 1869 return; 1870 1871 check_graph_reg(c, dti, node); 1872 1873 /* skip checks below for overlays */ 1874 if (dti->dtsflags & DTSF_PLUGIN) 1875 return; 1876 1877 if (!strprefixeq(node->name, node->basenamelen, "endpoint")) 1878 FAIL(c, dti, node, "graph endpoint node name should be 'endpoint'"); 1879 1880 remote_node = get_remote_endpoint(c, dti, node); 1881 if (!remote_node) 1882 return; 1883 1884 if (get_remote_endpoint(c, dti, remote_node) != node) 1885 FAIL(c, dti, node, "graph connection to node '%s' is not bidirectional", 1886 remote_node->fullpath); 1887 } 1888 WARNING(graph_endpoint, check_graph_endpoint, NULL, &graph_nodes); 1889 1890 static void check_graph_child_address(struct check *c, struct dt_info *dti, 1891 struct node *node) 1892 { 1893 int cnt = 0; 1894 struct node *child; 1895 1896 if (node->bus != &graph_ports_bus && node->bus != &graph_port_bus) 1897 return; 1898 1899 for_each_child(node, child) { 1900 struct property *prop = get_property(child, "reg"); 1901 1902 /* No error if we have any non-zero unit address */ 1903 if (prop && propval_cell(prop) != 0 ) 1904 return; 1905 1906 cnt++; 1907 } 1908 1909 if (cnt == 1 && node->addr_cells != -1) 1910 FAIL(c, dti, node, "graph node has single child node '%s', #address-cells/#size-cells are not necessary", 1911 node->children->name); 1912 } 1913 WARNING(graph_child_address, check_graph_child_address, NULL, &graph_nodes, &graph_port, &graph_endpoint); 1914 1915 static struct check *check_table[] = { 1916 &duplicate_node_names, &duplicate_property_names, 1917 &node_name_chars, &node_name_format, &property_name_chars, 1918 &name_is_string, &name_properties, &node_name_vs_property_name, 1919 1920 &duplicate_label, 1921 1922 &explicit_phandles, 1923 &phandle_references, &path_references, 1924 &omit_unused_nodes, 1925 1926 &address_cells_is_cell, &size_cells_is_cell, 1927 &device_type_is_string, &model_is_string, &status_is_string, 1928 &label_is_string, 1929 1930 &compatible_is_string_list, &names_is_string_list, 1931 1932 &property_name_chars_strict, 1933 &node_name_chars_strict, 1934 1935 &addr_size_cells, ®_format, &ranges_format, &dma_ranges_format, 1936 1937 &unit_address_vs_reg, 1938 &unit_address_format, 1939 1940 &pci_bridge, 1941 &pci_device_reg, 1942 &pci_device_bus_num, 1943 1944 &simple_bus_bridge, 1945 &simple_bus_reg, 1946 1947 &i2c_bus_bridge, 1948 &i2c_bus_reg, 1949 1950 &spi_bus_bridge, 1951 &spi_bus_reg, 1952 1953 &avoid_default_addr_size, 1954 &avoid_unnecessary_addr_size, 1955 &unique_unit_address, 1956 &unique_unit_address_if_enabled, 1957 &obsolete_chosen_interrupt_controller, 1958 &chosen_node_is_root, &chosen_node_bootargs, &chosen_node_stdout_path, 1959 1960 &clocks_property, 1961 &clocks_is_cell, 1962 &cooling_device_property, 1963 &cooling_device_is_cell, 1964 &dmas_property, 1965 &dmas_is_cell, 1966 &hwlocks_property, 1967 &hwlocks_is_cell, 1968 &interrupts_extended_property, 1969 &interrupts_extended_is_cell, 1970 &io_channels_property, 1971 &io_channels_is_cell, 1972 &iommus_property, 1973 &iommus_is_cell, 1974 &mboxes_property, 1975 &mboxes_is_cell, 1976 &msi_parent_property, 1977 &msi_parent_is_cell, 1978 &mux_controls_property, 1979 &mux_controls_is_cell, 1980 &phys_property, 1981 &phys_is_cell, 1982 &power_domains_property, 1983 &power_domains_is_cell, 1984 &pwms_property, 1985 &pwms_is_cell, 1986 &resets_property, 1987 &resets_is_cell, 1988 &sound_dai_property, 1989 &sound_dai_is_cell, 1990 &thermal_sensors_property, 1991 &thermal_sensors_is_cell, 1992 1993 &deprecated_gpio_property, 1994 &gpios_property, 1995 &interrupts_property, 1996 &interrupt_provider, 1997 &interrupt_map, 1998 1999 &alias_paths, 2000 2001 &graph_nodes, &graph_child_address, &graph_port, &graph_endpoint, 2002 2003 &always_fail, 2004 }; 2005 2006 static void enable_warning_error(struct check *c, bool warn, bool error) 2007 { 2008 int i; 2009 2010 /* Raising level, also raise it for prereqs */ 2011 if ((warn && !c->warn) || (error && !c->error)) 2012 for (i = 0; i < c->num_prereqs; i++) 2013 enable_warning_error(c->prereq[i], warn, error); 2014 2015 c->warn = c->warn || warn; 2016 c->error = c->error || error; 2017 } 2018 2019 static void disable_warning_error(struct check *c, bool warn, bool error) 2020 { 2021 unsigned int i; 2022 2023 /* Lowering level, also lower it for things this is the prereq 2024 * for */ 2025 if ((warn && c->warn) || (error && c->error)) { 2026 for (i = 0; i < ARRAY_SIZE(check_table); i++) { 2027 struct check *cc = check_table[i]; 2028 int j; 2029 2030 for (j = 0; j < cc->num_prereqs; j++) 2031 if (cc->prereq[j] == c) 2032 disable_warning_error(cc, warn, error); 2033 } 2034 } 2035 2036 c->warn = c->warn && !warn; 2037 c->error = c->error && !error; 2038 } 2039 2040 void parse_checks_option(bool warn, bool error, const char *arg) 2041 { 2042 unsigned int i; 2043 const char *name = arg; 2044 bool enable = true; 2045 2046 if ((strncmp(arg, "no-", 3) == 0) 2047 || (strncmp(arg, "no_", 3) == 0)) { 2048 name = arg + 3; 2049 enable = false; 2050 } 2051 2052 for (i = 0; i < ARRAY_SIZE(check_table); i++) { 2053 struct check *c = check_table[i]; 2054 2055 if (streq(c->name, name)) { 2056 if (enable) 2057 enable_warning_error(c, warn, error); 2058 else 2059 disable_warning_error(c, warn, error); 2060 return; 2061 } 2062 } 2063 2064 die("Unrecognized check name \"%s\"\n", name); 2065 } 2066 2067 void process_checks(bool force, struct dt_info *dti) 2068 { 2069 unsigned int i; 2070 int error = 0; 2071 2072 for (i = 0; i < ARRAY_SIZE(check_table); i++) { 2073 struct check *c = check_table[i]; 2074 2075 if (c->warn || c->error) 2076 error = error || run_check(c, dti); 2077 } 2078 2079 if (error) { 2080 if (!force) { 2081 fprintf(stderr, "ERROR: Input tree has errors, aborting " 2082 "(use -f to force output)\n"); 2083 exit(2); 2084 } else if (quiet < 3) { 2085 fprintf(stderr, "Warning: Input tree has errors, " 2086 "output forced\n"); 2087 } 2088 } 2089 } 2090