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, child->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 node *child; 1221 1222 if (!node->parent || node->addr_cells < 0 || node->size_cells < 0) 1223 return; 1224 1225 if (get_property(node, "ranges") || get_property(node, "dma-ranges") || !node->children) 1226 return; 1227 1228 for_each_child(node, child) { 1229 /* 1230 * Even if the child devices' address space is not mapped into 1231 * the parent bus (no 'ranges' property on node), children can 1232 * still have registers on a local bus, or map local addresses 1233 * to another subordinate address space. The properties on the 1234 * child nodes then make #address-cells/#size-cells necessary: 1235 */ 1236 if (get_property(child, "reg") || get_property(child, "ranges")) 1237 return; 1238 } 1239 1240 FAIL(c, dti, node, "unnecessary #address-cells/#size-cells without \"ranges\", \"dma-ranges\" or child \"reg\" or \"ranges\" property"); 1241 } 1242 WARNING(avoid_unnecessary_addr_size, check_avoid_unnecessary_addr_size, NULL, &avoid_default_addr_size); 1243 1244 static bool node_is_disabled(struct node *node) 1245 { 1246 struct property *prop; 1247 1248 prop = get_property(node, "status"); 1249 if (prop) { 1250 char *str = prop->val.val; 1251 if (streq("disabled", str)) 1252 return true; 1253 } 1254 1255 return false; 1256 } 1257 1258 static void check_unique_unit_address_common(struct check *c, 1259 struct dt_info *dti, 1260 struct node *node, 1261 bool disable_check) 1262 { 1263 struct node *childa; 1264 1265 if (node->addr_cells < 0 || node->size_cells < 0) 1266 return; 1267 1268 if (!node->children) 1269 return; 1270 1271 for_each_child(node, childa) { 1272 struct node *childb; 1273 const char *addr_a = get_unitname(childa); 1274 1275 if (!strlen(addr_a)) 1276 continue; 1277 1278 if (disable_check && node_is_disabled(childa)) 1279 continue; 1280 1281 for_each_child(node, childb) { 1282 const char *addr_b = get_unitname(childb); 1283 if (childa == childb) 1284 break; 1285 1286 if (disable_check && node_is_disabled(childb)) 1287 continue; 1288 1289 if (streq(addr_a, addr_b)) 1290 FAIL(c, dti, childb, "duplicate unit-address (also used in node %s)", childa->fullpath); 1291 } 1292 } 1293 } 1294 1295 static void check_unique_unit_address(struct check *c, struct dt_info *dti, 1296 struct node *node) 1297 { 1298 check_unique_unit_address_common(c, dti, node, false); 1299 } 1300 WARNING(unique_unit_address, check_unique_unit_address, NULL, &avoid_default_addr_size); 1301 1302 static void check_unique_unit_address_if_enabled(struct check *c, struct dt_info *dti, 1303 struct node *node) 1304 { 1305 check_unique_unit_address_common(c, dti, node, true); 1306 } 1307 CHECK_ENTRY(unique_unit_address_if_enabled, check_unique_unit_address_if_enabled, 1308 NULL, false, false, &avoid_default_addr_size); 1309 1310 static void check_obsolete_chosen_interrupt_controller(struct check *c, 1311 struct dt_info *dti, 1312 struct node *node) 1313 { 1314 struct node *dt = dti->dt; 1315 struct node *chosen; 1316 struct property *prop; 1317 1318 if (node != dt) 1319 return; 1320 1321 1322 chosen = get_node_by_path(dt, "/chosen"); 1323 if (!chosen) 1324 return; 1325 1326 prop = get_property(chosen, "interrupt-controller"); 1327 if (prop) 1328 FAIL_PROP(c, dti, node, prop, 1329 "/chosen has obsolete \"interrupt-controller\" property"); 1330 } 1331 WARNING(obsolete_chosen_interrupt_controller, 1332 check_obsolete_chosen_interrupt_controller, NULL); 1333 1334 static void check_chosen_node_is_root(struct check *c, struct dt_info *dti, 1335 struct node *node) 1336 { 1337 if (!streq(node->name, "chosen")) 1338 return; 1339 1340 if (node->parent != dti->dt) 1341 FAIL(c, dti, node, "chosen node must be at root node"); 1342 } 1343 WARNING(chosen_node_is_root, check_chosen_node_is_root, NULL); 1344 1345 static void check_chosen_node_bootargs(struct check *c, struct dt_info *dti, 1346 struct node *node) 1347 { 1348 struct property *prop; 1349 1350 if (!streq(node->name, "chosen")) 1351 return; 1352 1353 prop = get_property(node, "bootargs"); 1354 if (!prop) 1355 return; 1356 1357 c->data = prop->name; 1358 check_is_string(c, dti, node); 1359 } 1360 WARNING(chosen_node_bootargs, check_chosen_node_bootargs, NULL); 1361 1362 static void check_chosen_node_stdout_path(struct check *c, struct dt_info *dti, 1363 struct node *node) 1364 { 1365 struct property *prop; 1366 1367 if (!streq(node->name, "chosen")) 1368 return; 1369 1370 prop = get_property(node, "stdout-path"); 1371 if (!prop) { 1372 prop = get_property(node, "linux,stdout-path"); 1373 if (!prop) 1374 return; 1375 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead"); 1376 } 1377 1378 c->data = prop->name; 1379 check_is_string(c, dti, node); 1380 } 1381 WARNING(chosen_node_stdout_path, check_chosen_node_stdout_path, NULL); 1382 1383 struct provider { 1384 const char *prop_name; 1385 const char *cell_name; 1386 bool optional; 1387 }; 1388 1389 static void check_property_phandle_args(struct check *c, 1390 struct dt_info *dti, 1391 struct node *node, 1392 struct property *prop, 1393 const struct provider *provider) 1394 { 1395 struct node *root = dti->dt; 1396 unsigned int cell, cellsize = 0; 1397 1398 if (!is_multiple_of(prop->val.len, sizeof(cell_t))) { 1399 FAIL_PROP(c, dti, node, prop, 1400 "property size (%d) is invalid, expected multiple of %zu", 1401 prop->val.len, sizeof(cell_t)); 1402 return; 1403 } 1404 1405 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) { 1406 struct node *provider_node; 1407 struct property *cellprop; 1408 cell_t phandle; 1409 unsigned int expected; 1410 1411 phandle = propval_cell_n(prop, cell); 1412 /* 1413 * Some bindings use a cell value 0 or -1 to skip over optional 1414 * entries when each index position has a specific definition. 1415 */ 1416 if (!phandle_is_valid(phandle)) { 1417 /* Give up if this is an overlay with external references */ 1418 if (dti->dtsflags & DTSF_PLUGIN) 1419 break; 1420 1421 cellsize = 0; 1422 continue; 1423 } 1424 1425 /* If we have markers, verify the current cell is a phandle */ 1426 if (prop->val.markers) { 1427 struct marker *m = prop->val.markers; 1428 for_each_marker_of_type(m, REF_PHANDLE) { 1429 if (m->offset == (cell * sizeof(cell_t))) 1430 break; 1431 } 1432 if (!m) 1433 FAIL_PROP(c, dti, node, prop, 1434 "cell %d is not a phandle reference", 1435 cell); 1436 } 1437 1438 provider_node = get_node_by_phandle(root, phandle); 1439 if (!provider_node) { 1440 FAIL_PROP(c, dti, node, prop, 1441 "Could not get phandle node for (cell %d)", 1442 cell); 1443 break; 1444 } 1445 1446 cellprop = get_property(provider_node, provider->cell_name); 1447 if (cellprop) { 1448 cellsize = propval_cell(cellprop); 1449 } else if (provider->optional) { 1450 cellsize = 0; 1451 } else { 1452 FAIL(c, dti, node, "Missing property '%s' in node %s or bad phandle (referred from %s[%d])", 1453 provider->cell_name, 1454 provider_node->fullpath, 1455 prop->name, cell); 1456 break; 1457 } 1458 1459 expected = (cell + cellsize + 1) * sizeof(cell_t); 1460 if ((expected <= cell) || prop->val.len < expected) { 1461 FAIL_PROP(c, dti, node, prop, 1462 "property size (%d) too small for cell size %u", 1463 prop->val.len, cellsize); 1464 break; 1465 } 1466 } 1467 } 1468 1469 static void check_provider_cells_property(struct check *c, 1470 struct dt_info *dti, 1471 struct node *node) 1472 { 1473 const struct provider *provider = c->data; 1474 struct property *prop; 1475 1476 prop = get_property(node, provider->prop_name); 1477 if (!prop) 1478 return; 1479 1480 check_property_phandle_args(c, dti, node, prop, provider); 1481 } 1482 #define WARNING_PROPERTY_PHANDLE_CELLS(nm, propname, cells_name, ...) \ 1483 static struct provider nm##_provider = { (propname), (cells_name), __VA_ARGS__ }; \ 1484 WARNING_IF_NOT_CELL(nm##_is_cell, cells_name); \ 1485 WARNING(nm##_property, check_provider_cells_property, &nm##_provider, &nm##_is_cell, &phandle_references); 1486 1487 WARNING_PROPERTY_PHANDLE_CELLS(clocks, "clocks", "#clock-cells"); 1488 WARNING_PROPERTY_PHANDLE_CELLS(cooling_device, "cooling-device", "#cooling-cells"); 1489 WARNING_PROPERTY_PHANDLE_CELLS(dmas, "dmas", "#dma-cells"); 1490 WARNING_PROPERTY_PHANDLE_CELLS(hwlocks, "hwlocks", "#hwlock-cells"); 1491 WARNING_PROPERTY_PHANDLE_CELLS(interrupts_extended, "interrupts-extended", "#interrupt-cells"); 1492 WARNING_PROPERTY_PHANDLE_CELLS(io_channels, "io-channels", "#io-channel-cells"); 1493 WARNING_PROPERTY_PHANDLE_CELLS(iommus, "iommus", "#iommu-cells"); 1494 WARNING_PROPERTY_PHANDLE_CELLS(mboxes, "mboxes", "#mbox-cells"); 1495 WARNING_PROPERTY_PHANDLE_CELLS(msi_parent, "msi-parent", "#msi-cells", true); 1496 WARNING_PROPERTY_PHANDLE_CELLS(mux_controls, "mux-controls", "#mux-control-cells"); 1497 WARNING_PROPERTY_PHANDLE_CELLS(phys, "phys", "#phy-cells"); 1498 WARNING_PROPERTY_PHANDLE_CELLS(power_domains, "power-domains", "#power-domain-cells"); 1499 WARNING_PROPERTY_PHANDLE_CELLS(pwms, "pwms", "#pwm-cells"); 1500 WARNING_PROPERTY_PHANDLE_CELLS(resets, "resets", "#reset-cells"); 1501 WARNING_PROPERTY_PHANDLE_CELLS(sound_dai, "sound-dai", "#sound-dai-cells"); 1502 WARNING_PROPERTY_PHANDLE_CELLS(thermal_sensors, "thermal-sensors", "#thermal-sensor-cells"); 1503 1504 static bool prop_is_gpio(struct property *prop) 1505 { 1506 /* 1507 * *-gpios and *-gpio can appear in property names, 1508 * so skip over any false matches (only one known ATM) 1509 */ 1510 if (strends(prop->name, ",nr-gpios")) 1511 return false; 1512 1513 return strends(prop->name, "-gpios") || 1514 streq(prop->name, "gpios") || 1515 strends(prop->name, "-gpio") || 1516 streq(prop->name, "gpio"); 1517 } 1518 1519 static void check_gpios_property(struct check *c, 1520 struct dt_info *dti, 1521 struct node *node) 1522 { 1523 struct property *prop; 1524 1525 /* Skip GPIO hog nodes which have 'gpios' property */ 1526 if (get_property(node, "gpio-hog")) 1527 return; 1528 1529 for_each_property(node, prop) { 1530 struct provider provider; 1531 1532 if (!prop_is_gpio(prop)) 1533 continue; 1534 1535 provider.prop_name = prop->name; 1536 provider.cell_name = "#gpio-cells"; 1537 provider.optional = false; 1538 check_property_phandle_args(c, dti, node, prop, &provider); 1539 } 1540 1541 } 1542 WARNING(gpios_property, check_gpios_property, NULL, &phandle_references); 1543 1544 static void check_deprecated_gpio_property(struct check *c, 1545 struct dt_info *dti, 1546 struct node *node) 1547 { 1548 struct property *prop; 1549 1550 for_each_property(node, prop) { 1551 if (!prop_is_gpio(prop)) 1552 continue; 1553 1554 if (!strends(prop->name, "gpio")) 1555 continue; 1556 1557 FAIL_PROP(c, dti, node, prop, 1558 "'[*-]gpio' is deprecated, use '[*-]gpios' instead"); 1559 } 1560 1561 } 1562 CHECK(deprecated_gpio_property, check_deprecated_gpio_property, NULL); 1563 1564 static bool node_is_interrupt_provider(struct node *node) 1565 { 1566 struct property *prop; 1567 1568 prop = get_property(node, "interrupt-controller"); 1569 if (prop) 1570 return true; 1571 1572 prop = get_property(node, "interrupt-map"); 1573 if (prop) 1574 return true; 1575 1576 return false; 1577 } 1578 1579 static void check_interrupt_provider(struct check *c, 1580 struct dt_info *dti, 1581 struct node *node) 1582 { 1583 struct property *prop; 1584 bool irq_provider = node_is_interrupt_provider(node); 1585 1586 prop = get_property(node, "#interrupt-cells"); 1587 if (irq_provider && !prop) { 1588 FAIL(c, dti, node, 1589 "Missing '#interrupt-cells' in interrupt provider"); 1590 return; 1591 } 1592 1593 if (!irq_provider && prop) { 1594 FAIL(c, dti, node, 1595 "'#interrupt-cells' found, but node is not an interrupt provider"); 1596 return; 1597 } 1598 } 1599 WARNING(interrupt_provider, check_interrupt_provider, NULL, &interrupts_extended_is_cell); 1600 1601 static void check_interrupt_map(struct check *c, 1602 struct dt_info *dti, 1603 struct node *node) 1604 { 1605 struct node *root = dti->dt; 1606 struct property *prop, *irq_map_prop; 1607 size_t cellsize, cell, map_cells; 1608 1609 irq_map_prop = get_property(node, "interrupt-map"); 1610 if (!irq_map_prop) 1611 return; 1612 1613 if (node->addr_cells < 0) { 1614 FAIL(c, dti, node, 1615 "Missing '#address-cells' in interrupt-map provider"); 1616 return; 1617 } 1618 cellsize = node_addr_cells(node); 1619 cellsize += propval_cell(get_property(node, "#interrupt-cells")); 1620 1621 prop = get_property(node, "interrupt-map-mask"); 1622 if (prop && (prop->val.len != (cellsize * sizeof(cell_t)))) 1623 FAIL_PROP(c, dti, node, prop, 1624 "property size (%d) is invalid, expected %zu", 1625 prop->val.len, cellsize * sizeof(cell_t)); 1626 1627 if (!is_multiple_of(irq_map_prop->val.len, sizeof(cell_t))) { 1628 FAIL_PROP(c, dti, node, irq_map_prop, 1629 "property size (%d) is invalid, expected multiple of %zu", 1630 irq_map_prop->val.len, sizeof(cell_t)); 1631 return; 1632 } 1633 1634 map_cells = irq_map_prop->val.len / sizeof(cell_t); 1635 for (cell = 0; cell < map_cells; ) { 1636 struct node *provider_node; 1637 struct property *cellprop; 1638 int phandle; 1639 size_t parent_cellsize; 1640 1641 if ((cell + cellsize) >= map_cells) { 1642 FAIL_PROP(c, dti, node, irq_map_prop, 1643 "property size (%d) too small, expected > %zu", 1644 irq_map_prop->val.len, (cell + cellsize) * sizeof(cell_t)); 1645 break; 1646 } 1647 cell += cellsize; 1648 1649 phandle = propval_cell_n(irq_map_prop, cell); 1650 if (!phandle_is_valid(phandle)) { 1651 /* Give up if this is an overlay with external references */ 1652 if (!(dti->dtsflags & DTSF_PLUGIN)) 1653 FAIL_PROP(c, dti, node, irq_map_prop, 1654 "Cell %zu is not a phandle(%d)", 1655 cell, phandle); 1656 break; 1657 } 1658 1659 provider_node = get_node_by_phandle(root, phandle); 1660 if (!provider_node) { 1661 FAIL_PROP(c, dti, node, irq_map_prop, 1662 "Could not get phandle(%d) node for (cell %zu)", 1663 phandle, cell); 1664 break; 1665 } 1666 1667 cellprop = get_property(provider_node, "#interrupt-cells"); 1668 if (cellprop) { 1669 parent_cellsize = propval_cell(cellprop); 1670 } else { 1671 FAIL(c, dti, node, "Missing property '#interrupt-cells' in node %s or bad phandle (referred from interrupt-map[%zu])", 1672 provider_node->fullpath, cell); 1673 break; 1674 } 1675 1676 cellprop = get_property(provider_node, "#address-cells"); 1677 if (cellprop) 1678 parent_cellsize += propval_cell(cellprop); 1679 else 1680 FAIL_PROP(c, dti, node, irq_map_prop, 1681 "Missing property '#address-cells' in node %s, using 0 as fallback", 1682 provider_node->fullpath); 1683 1684 cell += 1 + parent_cellsize; 1685 if (cell > map_cells) 1686 FAIL_PROP(c, dti, node, irq_map_prop, 1687 "property size (%d) mismatch, expected %zu", 1688 irq_map_prop->val.len, cell * sizeof(cell_t)); 1689 } 1690 } 1691 WARNING(interrupt_map, check_interrupt_map, NULL, &phandle_references, &addr_size_cells, &interrupt_provider); 1692 1693 static void check_interrupts_property(struct check *c, 1694 struct dt_info *dti, 1695 struct node *node) 1696 { 1697 struct node *root = dti->dt; 1698 struct node *irq_node = NULL, *parent = node; 1699 struct property *irq_prop, *prop = NULL; 1700 cell_t irq_cells, phandle; 1701 1702 irq_prop = get_property(node, "interrupts"); 1703 if (!irq_prop) 1704 return; 1705 1706 if (!is_multiple_of(irq_prop->val.len, sizeof(cell_t))) 1707 FAIL_PROP(c, dti, node, irq_prop, "size (%d) is invalid, expected multiple of %zu", 1708 irq_prop->val.len, sizeof(cell_t)); 1709 1710 while (parent && !prop) { 1711 if (parent != node && node_is_interrupt_provider(parent)) { 1712 irq_node = parent; 1713 break; 1714 } 1715 1716 prop = get_property(parent, "interrupt-parent"); 1717 if (prop) { 1718 phandle = propval_cell(prop); 1719 if (!phandle_is_valid(phandle)) { 1720 /* Give up if this is an overlay with 1721 * external references */ 1722 if (dti->dtsflags & DTSF_PLUGIN) 1723 return; 1724 FAIL_PROP(c, dti, parent, prop, "Invalid phandle"); 1725 continue; 1726 } 1727 1728 irq_node = get_node_by_phandle(root, phandle); 1729 if (!irq_node) { 1730 FAIL_PROP(c, dti, parent, prop, "Bad phandle"); 1731 return; 1732 } 1733 if (!node_is_interrupt_provider(irq_node)) 1734 FAIL(c, dti, irq_node, 1735 "Missing interrupt-controller or interrupt-map property"); 1736 1737 break; 1738 } 1739 1740 parent = parent->parent; 1741 } 1742 1743 if (!irq_node) { 1744 FAIL(c, dti, node, "Missing interrupt-parent"); 1745 return; 1746 } 1747 1748 prop = get_property(irq_node, "#interrupt-cells"); 1749 if (!prop) { 1750 /* We warn about that already in another test. */ 1751 return; 1752 } 1753 1754 irq_cells = propval_cell(prop); 1755 if (!is_multiple_of(irq_prop->val.len, irq_cells * sizeof(cell_t))) { 1756 FAIL_PROP(c, dti, node, prop, 1757 "size is (%d), expected multiple of %d", 1758 irq_prop->val.len, (int)(irq_cells * sizeof(cell_t))); 1759 } 1760 } 1761 WARNING(interrupts_property, check_interrupts_property, &phandle_references); 1762 1763 static const struct bus_type graph_port_bus = { 1764 .name = "graph-port", 1765 }; 1766 1767 static const struct bus_type graph_ports_bus = { 1768 .name = "graph-ports", 1769 }; 1770 1771 static void check_graph_nodes(struct check *c, struct dt_info *dti, 1772 struct node *node) 1773 { 1774 struct node *child; 1775 1776 for_each_child(node, child) { 1777 if (!(strprefixeq(child->name, child->basenamelen, "endpoint") || 1778 get_property(child, "remote-endpoint"))) 1779 continue; 1780 1781 /* The root node cannot be a port */ 1782 if (!node->parent) { 1783 FAIL(c, dti, node, "root node contains endpoint node '%s', potentially misplaced remote-endpoint property", child->name); 1784 continue; 1785 } 1786 node->bus = &graph_port_bus; 1787 1788 /* The parent of 'port' nodes can be either 'ports' or a device */ 1789 if (!node->parent->bus && 1790 (streq(node->parent->name, "ports") || get_property(node, "reg"))) 1791 node->parent->bus = &graph_ports_bus; 1792 1793 break; 1794 } 1795 1796 } 1797 WARNING(graph_nodes, check_graph_nodes, NULL); 1798 1799 static void check_graph_reg(struct check *c, struct dt_info *dti, 1800 struct node *node) 1801 { 1802 char unit_addr[9]; 1803 const char *unitname = get_unitname(node); 1804 struct property *prop; 1805 1806 prop = get_property(node, "reg"); 1807 if (!prop || !unitname) 1808 return; 1809 1810 if (!(prop->val.val && prop->val.len == sizeof(cell_t))) { 1811 FAIL(c, dti, node, "graph node malformed 'reg' property"); 1812 return; 1813 } 1814 1815 snprintf(unit_addr, sizeof(unit_addr), "%x", propval_cell(prop)); 1816 if (!streq(unitname, unit_addr)) 1817 FAIL(c, dti, node, "graph node unit address error, expected \"%s\"", 1818 unit_addr); 1819 1820 if (node->parent->addr_cells != 1) 1821 FAIL_PROP(c, dti, node, get_property(node, "#address-cells"), 1822 "graph node '#address-cells' is %d, must be 1", 1823 node->parent->addr_cells); 1824 if (node->parent->size_cells != 0) 1825 FAIL_PROP(c, dti, node, get_property(node, "#size-cells"), 1826 "graph node '#size-cells' is %d, must be 0", 1827 node->parent->size_cells); 1828 } 1829 1830 static void check_graph_port(struct check *c, struct dt_info *dti, 1831 struct node *node) 1832 { 1833 if (node->bus != &graph_port_bus) 1834 return; 1835 1836 check_graph_reg(c, dti, node); 1837 1838 /* skip checks below for overlays */ 1839 if (dti->dtsflags & DTSF_PLUGIN) 1840 return; 1841 1842 if (!strprefixeq(node->name, node->basenamelen, "port")) 1843 FAIL(c, dti, node, "graph port node name should be 'port'"); 1844 } 1845 WARNING(graph_port, check_graph_port, NULL, &graph_nodes); 1846 1847 static struct node *get_remote_endpoint(struct check *c, struct dt_info *dti, 1848 struct node *endpoint) 1849 { 1850 cell_t phandle; 1851 struct node *node; 1852 struct property *prop; 1853 1854 prop = get_property(endpoint, "remote-endpoint"); 1855 if (!prop) 1856 return NULL; 1857 1858 phandle = propval_cell(prop); 1859 /* Give up if this is an overlay with external references */ 1860 if (!phandle_is_valid(phandle)) 1861 return NULL; 1862 1863 node = get_node_by_phandle(dti->dt, phandle); 1864 if (!node) 1865 FAIL_PROP(c, dti, endpoint, prop, "graph phandle is not valid"); 1866 1867 return node; 1868 } 1869 1870 static void check_graph_endpoint(struct check *c, struct dt_info *dti, 1871 struct node *node) 1872 { 1873 struct node *remote_node; 1874 1875 if (!node->parent || node->parent->bus != &graph_port_bus) 1876 return; 1877 1878 check_graph_reg(c, dti, node); 1879 1880 /* skip checks below for overlays */ 1881 if (dti->dtsflags & DTSF_PLUGIN) 1882 return; 1883 1884 if (!strprefixeq(node->name, node->basenamelen, "endpoint")) 1885 FAIL(c, dti, node, "graph endpoint node name should be 'endpoint'"); 1886 1887 remote_node = get_remote_endpoint(c, dti, node); 1888 if (!remote_node) 1889 return; 1890 1891 if (get_remote_endpoint(c, dti, remote_node) != node) 1892 FAIL(c, dti, node, "graph connection to node '%s' is not bidirectional", 1893 remote_node->fullpath); 1894 } 1895 WARNING(graph_endpoint, check_graph_endpoint, NULL, &graph_nodes); 1896 1897 static void check_graph_child_address(struct check *c, struct dt_info *dti, 1898 struct node *node) 1899 { 1900 int cnt = 0; 1901 struct node *child; 1902 1903 if (node->bus != &graph_ports_bus && node->bus != &graph_port_bus) 1904 return; 1905 1906 for_each_child(node, child) { 1907 struct property *prop = get_property(child, "reg"); 1908 1909 /* No error if we have any non-zero unit address */ 1910 if (prop && propval_cell(prop) != 0 ) 1911 return; 1912 1913 cnt++; 1914 } 1915 1916 if (cnt == 1 && node->addr_cells != -1) 1917 FAIL(c, dti, node, "graph node has single child node '%s', #address-cells/#size-cells are not necessary", 1918 node->children->name); 1919 } 1920 WARNING(graph_child_address, check_graph_child_address, NULL, &graph_nodes, &graph_port, &graph_endpoint); 1921 1922 static struct check *check_table[] = { 1923 &duplicate_node_names, &duplicate_property_names, 1924 &node_name_chars, &node_name_format, &property_name_chars, 1925 &name_is_string, &name_properties, &node_name_vs_property_name, 1926 1927 &duplicate_label, 1928 1929 &explicit_phandles, 1930 &phandle_references, &path_references, 1931 &omit_unused_nodes, 1932 1933 &address_cells_is_cell, &size_cells_is_cell, 1934 &device_type_is_string, &model_is_string, &status_is_string, 1935 &label_is_string, 1936 1937 &compatible_is_string_list, &names_is_string_list, 1938 1939 &property_name_chars_strict, 1940 &node_name_chars_strict, 1941 1942 &addr_size_cells, ®_format, &ranges_format, &dma_ranges_format, 1943 1944 &unit_address_vs_reg, 1945 &unit_address_format, 1946 1947 &pci_bridge, 1948 &pci_device_reg, 1949 &pci_device_bus_num, 1950 1951 &simple_bus_bridge, 1952 &simple_bus_reg, 1953 1954 &i2c_bus_bridge, 1955 &i2c_bus_reg, 1956 1957 &spi_bus_bridge, 1958 &spi_bus_reg, 1959 1960 &avoid_default_addr_size, 1961 &avoid_unnecessary_addr_size, 1962 &unique_unit_address, 1963 &unique_unit_address_if_enabled, 1964 &obsolete_chosen_interrupt_controller, 1965 &chosen_node_is_root, &chosen_node_bootargs, &chosen_node_stdout_path, 1966 1967 &clocks_property, 1968 &clocks_is_cell, 1969 &cooling_device_property, 1970 &cooling_device_is_cell, 1971 &dmas_property, 1972 &dmas_is_cell, 1973 &hwlocks_property, 1974 &hwlocks_is_cell, 1975 &interrupts_extended_property, 1976 &interrupts_extended_is_cell, 1977 &io_channels_property, 1978 &io_channels_is_cell, 1979 &iommus_property, 1980 &iommus_is_cell, 1981 &mboxes_property, 1982 &mboxes_is_cell, 1983 &msi_parent_property, 1984 &msi_parent_is_cell, 1985 &mux_controls_property, 1986 &mux_controls_is_cell, 1987 &phys_property, 1988 &phys_is_cell, 1989 &power_domains_property, 1990 &power_domains_is_cell, 1991 &pwms_property, 1992 &pwms_is_cell, 1993 &resets_property, 1994 &resets_is_cell, 1995 &sound_dai_property, 1996 &sound_dai_is_cell, 1997 &thermal_sensors_property, 1998 &thermal_sensors_is_cell, 1999 2000 &deprecated_gpio_property, 2001 &gpios_property, 2002 &interrupts_property, 2003 &interrupt_provider, 2004 &interrupt_map, 2005 2006 &alias_paths, 2007 2008 &graph_nodes, &graph_child_address, &graph_port, &graph_endpoint, 2009 2010 &always_fail, 2011 }; 2012 2013 static void enable_warning_error(struct check *c, bool warn, bool error) 2014 { 2015 int i; 2016 2017 /* Raising level, also raise it for prereqs */ 2018 if ((warn && !c->warn) || (error && !c->error)) 2019 for (i = 0; i < c->num_prereqs; i++) 2020 enable_warning_error(c->prereq[i], warn, error); 2021 2022 c->warn = c->warn || warn; 2023 c->error = c->error || error; 2024 } 2025 2026 static void disable_warning_error(struct check *c, bool warn, bool error) 2027 { 2028 unsigned int i; 2029 2030 /* Lowering level, also lower it for things this is the prereq 2031 * for */ 2032 if ((warn && c->warn) || (error && c->error)) { 2033 for (i = 0; i < ARRAY_SIZE(check_table); i++) { 2034 struct check *cc = check_table[i]; 2035 int j; 2036 2037 for (j = 0; j < cc->num_prereqs; j++) 2038 if (cc->prereq[j] == c) 2039 disable_warning_error(cc, warn, error); 2040 } 2041 } 2042 2043 c->warn = c->warn && !warn; 2044 c->error = c->error && !error; 2045 } 2046 2047 void parse_checks_option(bool warn, bool error, const char *arg) 2048 { 2049 unsigned int i; 2050 const char *name = arg; 2051 bool enable = true; 2052 2053 if ((strncmp(arg, "no-", 3) == 0) 2054 || (strncmp(arg, "no_", 3) == 0)) { 2055 name = arg + 3; 2056 enable = false; 2057 } 2058 2059 for (i = 0; i < ARRAY_SIZE(check_table); i++) { 2060 struct check *c = check_table[i]; 2061 2062 if (streq(c->name, name)) { 2063 if (enable) 2064 enable_warning_error(c, warn, error); 2065 else 2066 disable_warning_error(c, warn, error); 2067 return; 2068 } 2069 } 2070 2071 die("Unrecognized check name \"%s\"\n", name); 2072 } 2073 2074 void process_checks(bool force, struct dt_info *dti) 2075 { 2076 unsigned int i; 2077 int error = 0; 2078 2079 for (i = 0; i < ARRAY_SIZE(check_table); i++) { 2080 struct check *c = check_table[i]; 2081 2082 if (c->warn || c->error) 2083 error = error || run_check(c, dti); 2084 } 2085 2086 if (error) { 2087 if (!force) { 2088 fprintf(stderr, "ERROR: Input tree has errors, aborting " 2089 "(use -f to force output)\n"); 2090 exit(2); 2091 } else if (quiet < 3) { 2092 fprintf(stderr, "Warning: Input tree has errors, " 2093 "output forced\n"); 2094 } 2095 } 2096 } 2097