scripts/dtc: Update to upstream version v1.4.6-9-gaadd0b65c987

+3 -3

include/linux/libfdt_env.h

··· 1 1 /* SPDX-License-Identifier: GPL-2.0 */ 2 - #ifndef _LIBFDT_ENV_H 3 - #define _LIBFDT_ENV_H 2 + #ifndef LIBFDT_ENV_H 3 + #define LIBFDT_ENV_H 4 4 5 5 #include <linux/string.h> 6 6 ··· 15 15 #define fdt64_to_cpu(x) be64_to_cpu(x) 16 16 #define cpu_to_fdt64(x) cpu_to_be64(x) 17 17 18 - #endif /* _LIBFDT_ENV_H */ 18 + #endif /* LIBFDT_ENV_H */

+289 -148

scripts/dtc/checks.c

··· 53 53 struct check **prereq; 54 54 }; 55 55 56 - #define CHECK_ENTRY(_nm, _fn, _d, _w, _e, ...) \ 57 - static struct check *_nm##_prereqs[] = { __VA_ARGS__ }; \ 58 - static struct check _nm = { \ 59 - .name = #_nm, \ 60 - .fn = (_fn), \ 61 - .data = (_d), \ 62 - .warn = (_w), \ 63 - .error = (_e), \ 56 + #define CHECK_ENTRY(nm_, fn_, d_, w_, e_, ...) \ 57 + static struct check *nm_##_prereqs[] = { __VA_ARGS__ }; \ 58 + static struct check nm_ = { \ 59 + .name = #nm_, \ 60 + .fn = (fn_), \ 61 + .data = (d_), \ 62 + .warn = (w_), \ 63 + .error = (e_), \ 64 64 .status = UNCHECKED, \ 65 - .num_prereqs = ARRAY_SIZE(_nm##_prereqs), \ 66 - .prereq = _nm##_prereqs, \ 65 + .num_prereqs = ARRAY_SIZE(nm_##_prereqs), \ 66 + .prereq = nm_##_prereqs, \ 67 67 }; 68 - #define WARNING(_nm, _fn, _d, ...) \ 69 - CHECK_ENTRY(_nm, _fn, _d, true, false, __VA_ARGS__) 70 - #define ERROR(_nm, _fn, _d, ...) \ 71 - CHECK_ENTRY(_nm, _fn, _d, false, true, __VA_ARGS__) 72 - #define CHECK(_nm, _fn, _d, ...) \ 73 - CHECK_ENTRY(_nm, _fn, _d, false, false, __VA_ARGS__) 68 + #define WARNING(nm_, fn_, d_, ...) \ 69 + CHECK_ENTRY(nm_, fn_, d_, true, false, __VA_ARGS__) 70 + #define ERROR(nm_, fn_, d_, ...) \ 71 + CHECK_ENTRY(nm_, fn_, d_, false, true, __VA_ARGS__) 72 + #define CHECK(nm_, fn_, d_, ...) \ 73 + CHECK_ENTRY(nm_, fn_, d_, false, false, __VA_ARGS__) 74 74 75 - static inline void PRINTF(3, 4) check_msg(struct check *c, struct dt_info *dti, 75 + static inline void PRINTF(5, 6) check_msg(struct check *c, struct dt_info *dti, 76 + struct node *node, 77 + struct property *prop, 76 78 const char *fmt, ...) 77 79 { 78 80 va_list ap; ··· 85 83 fprintf(stderr, "%s: %s (%s): ", 86 84 strcmp(dti->outname, "-") ? dti->outname : "<stdout>", 87 85 (c->error) ? "ERROR" : "Warning", c->name); 86 + if (node) { 87 + fprintf(stderr, "%s", node->fullpath); 88 + if (prop) 89 + fprintf(stderr, ":%s", prop->name); 90 + fputs(": ", stderr); 91 + } 88 92 vfprintf(stderr, fmt, ap); 89 93 fprintf(stderr, "\n"); 90 94 } 91 95 va_end(ap); 92 96 } 93 97 94 - #define FAIL(c, dti, ...) \ 98 + #define FAIL(c, dti, node, ...) \ 95 99 do { \ 96 100 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \ 97 101 (c)->status = FAILED; \ 98 - check_msg((c), dti, __VA_ARGS__); \ 102 + check_msg((c), dti, node, NULL, __VA_ARGS__); \ 99 103 } while (0) 104 + 105 + #define FAIL_PROP(c, dti, node, prop, ...) \ 106 + do { \ 107 + TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \ 108 + (c)->status = FAILED; \ 109 + check_msg((c), dti, node, prop, __VA_ARGS__); \ 110 + } while (0) 111 + 100 112 101 113 static void check_nodes_props(struct check *c, struct dt_info *dti, struct node *node) 102 114 { ··· 142 126 error = error || run_check(prq, dti); 143 127 if (prq->status != PASSED) { 144 128 c->status = PREREQ; 145 - check_msg(c, dti, "Failed prerequisite '%s'", 129 + check_msg(c, dti, NULL, NULL, "Failed prerequisite '%s'", 146 130 c->prereq[i]->name); 147 131 } 148 132 } ··· 172 156 static inline void check_always_fail(struct check *c, struct dt_info *dti, 173 157 struct node *node) 174 158 { 175 - FAIL(c, dti, "always_fail check"); 159 + FAIL(c, dti, node, "always_fail check"); 176 160 } 177 161 CHECK(always_fail, check_always_fail, NULL); 178 162 ··· 187 171 return; /* Not present, assumed ok */ 188 172 189 173 if (!data_is_one_string(prop->val)) 190 - FAIL(c, dti, "\"%s\" property in %s is not a string", 191 - propname, node->fullpath); 174 + FAIL_PROP(c, dti, node, prop, "property is not a string"); 192 175 } 193 176 #define WARNING_IF_NOT_STRING(nm, propname) \ 194 177 WARNING(nm, check_is_string, (propname)) 195 178 #define ERROR_IF_NOT_STRING(nm, propname) \ 196 179 ERROR(nm, check_is_string, (propname)) 180 + 181 + static void check_is_string_list(struct check *c, struct dt_info *dti, 182 + struct node *node) 183 + { 184 + int rem, l; 185 + struct property *prop; 186 + char *propname = c->data; 187 + char *str; 188 + 189 + prop = get_property(node, propname); 190 + if (!prop) 191 + return; /* Not present, assumed ok */ 192 + 193 + str = prop->val.val; 194 + rem = prop->val.len; 195 + while (rem > 0) { 196 + l = strnlen(str, rem); 197 + if (l == rem) { 198 + FAIL_PROP(c, dti, node, prop, "property is not a string list"); 199 + break; 200 + } 201 + rem -= l + 1; 202 + str += l + 1; 203 + } 204 + } 205 + #define WARNING_IF_NOT_STRING_LIST(nm, propname) \ 206 + WARNING(nm, check_is_string_list, (propname)) 207 + #define ERROR_IF_NOT_STRING_LIST(nm, propname) \ 208 + ERROR(nm, check_is_string_list, (propname)) 197 209 198 210 static void check_is_cell(struct check *c, struct dt_info *dti, 199 211 struct node *node) ··· 234 190 return; /* Not present, assumed ok */ 235 191 236 192 if (prop->val.len != sizeof(cell_t)) 237 - FAIL(c, dti, "\"%s\" property in %s is not a single cell", 238 - propname, node->fullpath); 193 + FAIL_PROP(c, dti, node, prop, "property is not a single cell"); 239 194 } 240 195 #define WARNING_IF_NOT_CELL(nm, propname) \ 241 196 WARNING(nm, check_is_cell, (propname)) ··· 255 212 child2; 256 213 child2 = child2->next_sibling) 257 214 if (streq(child->name, child2->name)) 258 - FAIL(c, dti, "Duplicate node name %s", 259 - child->fullpath); 215 + FAIL(c, dti, node, "Duplicate node name"); 260 216 } 261 217 ERROR(duplicate_node_names, check_duplicate_node_names, NULL); 262 218 ··· 269 227 if (prop2->deleted) 270 228 continue; 271 229 if (streq(prop->name, prop2->name)) 272 - FAIL(c, dti, "Duplicate property name %s in %s", 273 - prop->name, node->fullpath); 230 + FAIL_PROP(c, dti, node, prop, "Duplicate property name"); 274 231 } 275 232 } 276 233 } ··· 287 246 int n = strspn(node->name, c->data); 288 247 289 248 if (n < strlen(node->name)) 290 - FAIL(c, dti, "Bad character '%c' in node %s", 291 - node->name[n], node->fullpath); 249 + FAIL(c, dti, node, "Bad character '%c' in node name", 250 + node->name[n]); 292 251 } 293 252 ERROR(node_name_chars, check_node_name_chars, PROPNODECHARS "@"); 294 253 ··· 298 257 int n = strspn(node->name, c->data); 299 258 300 259 if (n < node->basenamelen) 301 - FAIL(c, dti, "Character '%c' not recommended in node %s", 302 - node->name[n], node->fullpath); 260 + FAIL(c, dti, node, "Character '%c' not recommended in node name", 261 + node->name[n]); 303 262 } 304 263 CHECK(node_name_chars_strict, check_node_name_chars_strict, PROPNODECHARSSTRICT); 305 264 ··· 307 266 struct node *node) 308 267 { 309 268 if (strchr(get_unitname(node), '@')) 310 - FAIL(c, dti, "Node %s has multiple '@' characters in name", 311 - node->fullpath); 269 + FAIL(c, dti, node, "multiple '@' characters in node name"); 312 270 } 313 271 ERROR(node_name_format, check_node_name_format, NULL, &node_name_chars); 314 272 ··· 325 285 326 286 if (prop) { 327 287 if (!unitname[0]) 328 - FAIL(c, dti, "Node %s has a reg or ranges property, but no unit name", 329 - node->fullpath); 288 + FAIL(c, dti, node, "node has a reg or ranges property, but no unit name"); 330 289 } else { 331 290 if (unitname[0]) 332 - FAIL(c, dti, "Node %s has a unit name, but no reg property", 333 - node->fullpath); 291 + FAIL(c, dti, node, "node has a unit name, but no reg property"); 334 292 } 335 293 } 336 294 WARNING(unit_address_vs_reg, check_unit_address_vs_reg, NULL); ··· 342 304 int n = strspn(prop->name, c->data); 343 305 344 306 if (n < strlen(prop->name)) 345 - FAIL(c, dti, "Bad character '%c' in property name \"%s\", node %s", 346 - prop->name[n], prop->name, node->fullpath); 307 + FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name", 308 + prop->name[n]); 347 309 } 348 310 } 349 311 ERROR(property_name_chars, check_property_name_chars, PROPNODECHARS); ··· 374 336 n = strspn(name, c->data); 375 337 } 376 338 if (n < strlen(name)) 377 - FAIL(c, dti, "Character '%c' not recommended in property name \"%s\", node %s", 378 - name[n], prop->name, node->fullpath); 339 + FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name", 340 + name[n]); 379 341 } 380 342 } 381 343 CHECK(property_name_chars_strict, check_property_name_chars_strict, PROPNODECHARSSTRICT); ··· 408 370 return; 409 371 410 372 if ((othernode != node) || (otherprop != prop) || (othermark != mark)) 411 - FAIL(c, dti, "Duplicate label '%s' on " DESCLABEL_FMT 373 + FAIL(c, dti, node, "Duplicate label '%s' on " DESCLABEL_FMT 412 374 " and " DESCLABEL_FMT, 413 375 label, DESCLABEL_ARGS(node, prop, mark), 414 376 DESCLABEL_ARGS(othernode, otherprop, othermark)); ··· 448 410 return 0; 449 411 450 412 if (prop->val.len != sizeof(cell_t)) { 451 - FAIL(c, dti, "%s has bad length (%d) %s property", 452 - node->fullpath, prop->val.len, prop->name); 413 + FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property", 414 + prop->val.len, prop->name); 453 415 return 0; 454 416 } 455 417 ··· 460 422 /* "Set this node's phandle equal to some 461 423 * other node's phandle". That's nonsensical 462 424 * by construction. */ { 463 - FAIL(c, dti, "%s in %s is a reference to another node", 464 - prop->name, node->fullpath); 425 + FAIL(c, dti, node, "%s is a reference to another node", 426 + prop->name); 465 427 } 466 428 /* But setting this node's phandle equal to its own 467 429 * phandle is allowed - that means allocate a unique ··· 474 436 phandle = propval_cell(prop); 475 437 476 438 if ((phandle == 0) || (phandle == -1)) { 477 - FAIL(c, dti, "%s has bad value (0x%x) in %s property", 478 - node->fullpath, phandle, prop->name); 439 + FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property", 440 + phandle, prop->name); 479 441 return 0; 480 442 } 481 443 ··· 501 463 return; 502 464 503 465 if (linux_phandle && phandle && (phandle != linux_phandle)) 504 - FAIL(c, dti, "%s has mismatching 'phandle' and 'linux,phandle'" 505 - " properties", node->fullpath); 466 + FAIL(c, dti, node, "mismatching 'phandle' and 'linux,phandle'" 467 + " properties"); 506 468 507 469 if (linux_phandle && !phandle) 508 470 phandle = linux_phandle; 509 471 510 472 other = get_node_by_phandle(root, phandle); 511 473 if (other && (other != node)) { 512 - FAIL(c, dti, "%s has duplicated phandle 0x%x (seen before at %s)", 513 - node->fullpath, phandle, other->fullpath); 474 + FAIL(c, dti, node, "duplicated phandle 0x%x (seen before at %s)", 475 + phandle, other->fullpath); 514 476 return; 515 477 } 516 478 ··· 534 496 535 497 if ((prop->val.len != node->basenamelen+1) 536 498 || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) { 537 - FAIL(c, dti, "\"name\" property in %s is incorrect (\"%s\" instead" 538 - " of base node name)", node->fullpath, prop->val.val); 499 + FAIL(c, dti, node, "\"name\" property is incorrect (\"%s\" instead" 500 + " of base node name)", prop->val.val); 539 501 } else { 540 502 /* The name property is correct, and therefore redundant. 541 503 * Delete it */ ··· 569 531 refnode = get_node_by_ref(dt, m->ref); 570 532 if (! refnode) { 571 533 if (!(dti->dtsflags & DTSF_PLUGIN)) 572 - FAIL(c, dti, "Reference to non-existent node or " 534 + FAIL(c, dti, node, "Reference to non-existent node or " 573 535 "label \"%s\"\n", m->ref); 574 536 else /* mark the entry as unresolved */ 575 537 *((fdt32_t *)(prop->val.val + m->offset)) = ··· 601 563 602 564 refnode = get_node_by_ref(dt, m->ref); 603 565 if (!refnode) { 604 - FAIL(c, dti, "Reference to non-existent node or label \"%s\"\n", 566 + FAIL(c, dti, node, "Reference to non-existent node or label \"%s\"\n", 605 567 m->ref); 606 568 continue; 607 569 } ··· 624 586 WARNING_IF_NOT_STRING(device_type_is_string, "device_type"); 625 587 WARNING_IF_NOT_STRING(model_is_string, "model"); 626 588 WARNING_IF_NOT_STRING(status_is_string, "status"); 589 + WARNING_IF_NOT_STRING(label_is_string, "label"); 590 + 591 + WARNING_IF_NOT_STRING_LIST(compatible_is_string_list, "compatible"); 592 + 593 + static void check_names_is_string_list(struct check *c, struct dt_info *dti, 594 + struct node *node) 595 + { 596 + struct property *prop; 597 + 598 + for_each_property(node, prop) { 599 + const char *s = strrchr(prop->name, '-'); 600 + if (!s || !streq(s, "-names")) 601 + continue; 602 + 603 + c->data = prop->name; 604 + check_is_string_list(c, dti, node); 605 + } 606 + } 607 + WARNING(names_is_string_list, check_names_is_string_list, NULL); 608 + 609 + static void check_alias_paths(struct check *c, struct dt_info *dti, 610 + struct node *node) 611 + { 612 + struct property *prop; 613 + 614 + if (!streq(node->name, "aliases")) 615 + return; 616 + 617 + for_each_property(node, prop) { 618 + if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) { 619 + FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)", 620 + prop->val.val); 621 + continue; 622 + } 623 + if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name)) 624 + FAIL(c, dti, node, "aliases property name must include only lowercase and '-'"); 625 + } 626 + } 627 + WARNING(alias_paths, check_alias_paths, NULL); 627 628 628 629 static void fixup_addr_size_cells(struct check *c, struct dt_info *dti, 629 630 struct node *node) ··· 699 622 return; /* No "reg", that's fine */ 700 623 701 624 if (!node->parent) { 702 - FAIL(c, dti, "Root node has a \"reg\" property"); 625 + FAIL(c, dti, node, "Root node has a \"reg\" property"); 703 626 return; 704 627 } 705 628 706 629 if (prop->val.len == 0) 707 - FAIL(c, dti, "\"reg\" property in %s is empty", node->fullpath); 630 + FAIL_PROP(c, dti, node, prop, "property is empty"); 708 631 709 632 addr_cells = node_addr_cells(node->parent); 710 633 size_cells = node_size_cells(node->parent); 711 634 entrylen = (addr_cells + size_cells) * sizeof(cell_t); 712 635 713 636 if (!entrylen || (prop->val.len % entrylen) != 0) 714 - FAIL(c, dti, "\"reg\" property in %s has invalid length (%d bytes) " 715 - "(#address-cells == %d, #size-cells == %d)", 716 - node->fullpath, prop->val.len, addr_cells, size_cells); 637 + FAIL_PROP(c, dti, node, prop, "property has invalid length (%d bytes) " 638 + "(#address-cells == %d, #size-cells == %d)", 639 + prop->val.len, addr_cells, size_cells); 717 640 } 718 641 WARNING(reg_format, check_reg_format, NULL, &addr_size_cells); 719 642 ··· 728 651 return; 729 652 730 653 if (!node->parent) { 731 - FAIL(c, dti, "Root node has a \"ranges\" property"); 654 + FAIL_PROP(c, dti, node, prop, "Root node has a \"ranges\" property"); 732 655 return; 733 656 } 734 657 ··· 740 663 741 664 if (prop->val.len == 0) { 742 665 if (p_addr_cells != c_addr_cells) 743 - FAIL(c, dti, "%s has empty \"ranges\" property but its " 744 - "#address-cells (%d) differs from %s (%d)", 745 - node->fullpath, c_addr_cells, node->parent->fullpath, 746 - p_addr_cells); 666 + FAIL_PROP(c, dti, node, prop, "empty \"ranges\" property but its " 667 + "#address-cells (%d) differs from %s (%d)", 668 + c_addr_cells, node->parent->fullpath, 669 + p_addr_cells); 747 670 if (p_size_cells != c_size_cells) 748 - FAIL(c, dti, "%s has empty \"ranges\" property but its " 749 - "#size-cells (%d) differs from %s (%d)", 750 - node->fullpath, c_size_cells, node->parent->fullpath, 751 - p_size_cells); 671 + FAIL_PROP(c, dti, node, prop, "empty \"ranges\" property but its " 672 + "#size-cells (%d) differs from %s (%d)", 673 + c_size_cells, node->parent->fullpath, 674 + p_size_cells); 752 675 } else if ((prop->val.len % entrylen) != 0) { 753 - FAIL(c, dti, "\"ranges\" property in %s has invalid length (%d bytes) " 754 - "(parent #address-cells == %d, child #address-cells == %d, " 755 - "#size-cells == %d)", node->fullpath, prop->val.len, 756 - p_addr_cells, c_addr_cells, c_size_cells); 676 + FAIL_PROP(c, dti, node, prop, "\"ranges\" property has invalid length (%d bytes) " 677 + "(parent #address-cells == %d, child #address-cells == %d, " 678 + "#size-cells == %d)", prop->val.len, 679 + p_addr_cells, c_addr_cells, c_size_cells); 757 680 } 758 681 } 759 682 WARNING(ranges_format, check_ranges_format, NULL, &addr_size_cells); ··· 773 696 774 697 node->bus = &pci_bus; 775 698 776 - if (!strneq(node->name, "pci", node->basenamelen) && 777 - !strneq(node->name, "pcie", node->basenamelen)) 778 - FAIL(c, dti, "Node %s node name is not \"pci\" or \"pcie\"", 779 - node->fullpath); 699 + if (!strprefixeq(node->name, node->basenamelen, "pci") && 700 + !strprefixeq(node->name, node->basenamelen, "pcie")) 701 + FAIL(c, dti, node, "node name is not \"pci\" or \"pcie\""); 780 702 781 703 prop = get_property(node, "ranges"); 782 704 if (!prop) 783 - FAIL(c, dti, "Node %s missing ranges for PCI bridge (or not a bridge)", 784 - node->fullpath); 705 + FAIL(c, dti, node, "missing ranges for PCI bridge (or not a bridge)"); 785 706 786 707 if (node_addr_cells(node) != 3) 787 - FAIL(c, dti, "Node %s incorrect #address-cells for PCI bridge", 788 - node->fullpath); 708 + FAIL(c, dti, node, "incorrect #address-cells for PCI bridge"); 789 709 if (node_size_cells(node) != 2) 790 - FAIL(c, dti, "Node %s incorrect #size-cells for PCI bridge", 791 - node->fullpath); 710 + FAIL(c, dti, node, "incorrect #size-cells for PCI bridge"); 792 711 793 712 prop = get_property(node, "bus-range"); 794 713 if (!prop) { 795 - FAIL(c, dti, "Node %s missing bus-range for PCI bridge", 796 - node->fullpath); 714 + FAIL(c, dti, node, "missing bus-range for PCI bridge"); 797 715 return; 798 716 } 799 717 if (prop->val.len != (sizeof(cell_t) * 2)) { 800 - FAIL(c, dti, "Node %s bus-range must be 2 cells", 801 - node->fullpath); 718 + FAIL_PROP(c, dti, node, prop, "value must be 2 cells"); 802 719 return; 803 720 } 804 721 cells = (cell_t *)prop->val.val; 805 722 if (fdt32_to_cpu(cells[0]) > fdt32_to_cpu(cells[1])) 806 - FAIL(c, dti, "Node %s bus-range 1st cell must be less than or equal to 2nd cell", 807 - node->fullpath); 723 + FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell"); 808 724 if (fdt32_to_cpu(cells[1]) > 0xff) 809 - FAIL(c, dti, "Node %s bus-range maximum bus number must be less than 256", 810 - node->fullpath); 725 + FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256"); 811 726 } 812 727 WARNING(pci_bridge, check_pci_bridge, NULL, 813 728 &device_type_is_string, &addr_size_cells); ··· 829 760 max_bus = fdt32_to_cpu(cells[0]); 830 761 } 831 762 if ((bus_num < min_bus) || (bus_num > max_bus)) 832 - FAIL(c, dti, "Node %s PCI bus number %d out of range, expected (%d - %d)", 833 - node->fullpath, bus_num, min_bus, max_bus); 763 + FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)", 764 + bus_num, min_bus, max_bus); 834 765 } 835 766 WARNING(pci_device_bus_num, check_pci_device_bus_num, NULL, &reg_format, &pci_bridge); 836 767 ··· 847 778 848 779 prop = get_property(node, "reg"); 849 780 if (!prop) { 850 - FAIL(c, dti, "Node %s missing PCI reg property", node->fullpath); 781 + FAIL(c, dti, node, "missing PCI reg property"); 851 782 return; 852 783 } 853 784 854 785 cells = (cell_t *)prop->val.val; 855 786 if (cells[1] || cells[2]) 856 - FAIL(c, dti, "Node %s PCI reg config space address cells 2 and 3 must be 0", 857 - node->fullpath); 787 + FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0"); 858 788 859 789 reg = fdt32_to_cpu(cells[0]); 860 790 dev = (reg & 0xf800) >> 11; 861 791 func = (reg & 0x700) >> 8; 862 792 863 793 if (reg & 0xff000000) 864 - FAIL(c, dti, "Node %s PCI reg address is not configuration space", 865 - node->fullpath); 794 + FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space"); 866 795 if (reg & 0x000000ff) 867 - FAIL(c, dti, "Node %s PCI reg config space address register number must be 0", 868 - node->fullpath); 796 + FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0"); 869 797 870 798 if (func == 0) { 871 799 snprintf(unit_addr, sizeof(unit_addr), "%x", dev); ··· 874 808 if (streq(unitname, unit_addr)) 875 809 return; 876 810 877 - FAIL(c, dti, "Node %s PCI unit address format error, expected \"%s\"", 878 - node->fullpath, unit_addr); 811 + FAIL(c, dti, node, "PCI unit address format error, expected \"%s\"", 812 + unit_addr); 879 813 } 880 814 WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format, &pci_bridge); 881 815 ··· 894 828 895 829 for (str = prop->val.val, end = str + prop->val.len; str < end; 896 830 str += strnlen(str, end - str) + 1) { 897 - if (strneq(str, compat, end - str)) 831 + if (strprefixeq(str, end - str, compat)) 898 832 return true; 899 833 } 900 834 return false; ··· 931 865 932 866 if (!cells) { 933 867 if (node->parent->parent && !(node->bus == &simple_bus)) 934 - FAIL(c, dti, "Node %s missing or empty reg/ranges property", node->fullpath); 868 + FAIL(c, dti, node, "missing or empty reg/ranges property"); 935 869 return; 936 870 } 937 871 ··· 941 875 942 876 snprintf(unit_addr, sizeof(unit_addr), "%"PRIx64, reg); 943 877 if (!streq(unitname, unit_addr)) 944 - FAIL(c, dti, "Node %s simple-bus unit address format error, expected \"%s\"", 945 - node->fullpath, unit_addr); 878 + FAIL(c, dti, node, "simple-bus unit address format error, expected \"%s\"", 879 + unit_addr); 946 880 } 947 881 WARNING(simple_bus_reg, check_simple_bus_reg, NULL, &reg_format, &simple_bus_bridge); 948 882 ··· 958 892 return; 959 893 960 894 if (!strncmp(unitname, "0x", 2)) { 961 - FAIL(c, dti, "Node %s unit name should not have leading \"0x\"", 962 - node->fullpath); 895 + FAIL(c, dti, node, "unit name should not have leading \"0x\""); 963 896 /* skip over 0x for next test */ 964 897 unitname += 2; 965 898 } 966 899 if (unitname[0] == '0' && isxdigit(unitname[1])) 967 - FAIL(c, dti, "Node %s unit name should not have leading 0s", 968 - node->fullpath); 900 + FAIL(c, dti, node, "unit name should not have leading 0s"); 969 901 } 970 902 WARNING(unit_address_format, check_unit_address_format, NULL, 971 903 &node_name_format, &pci_bridge, &simple_bus_bridge); ··· 986 922 return; 987 923 988 924 if (node->parent->addr_cells == -1) 989 - FAIL(c, dti, "Relying on default #address-cells value for %s", 990 - node->fullpath); 925 + FAIL(c, dti, node, "Relying on default #address-cells value"); 991 926 992 927 if (node->parent->size_cells == -1) 993 - FAIL(c, dti, "Relying on default #size-cells value for %s", 994 - node->fullpath); 928 + FAIL(c, dti, node, "Relying on default #size-cells value"); 995 929 } 996 930 WARNING(avoid_default_addr_size, check_avoid_default_addr_size, NULL, 997 931 &addr_size_cells); 932 + 933 + static void check_avoid_unnecessary_addr_size(struct check *c, struct dt_info *dti, 934 + struct node *node) 935 + { 936 + struct property *prop; 937 + struct node *child; 938 + bool has_reg = false; 939 + 940 + if (!node->parent || node->addr_cells < 0 || node->size_cells < 0) 941 + return; 942 + 943 + if (get_property(node, "ranges") || !node->children) 944 + return; 945 + 946 + for_each_child(node, child) { 947 + prop = get_property(child, "reg"); 948 + if (prop) 949 + has_reg = true; 950 + } 951 + 952 + if (!has_reg) 953 + FAIL(c, dti, node, "unnecessary #address-cells/#size-cells without \"ranges\" or child \"reg\" property"); 954 + } 955 + WARNING(avoid_unnecessary_addr_size, check_avoid_unnecessary_addr_size, NULL, &avoid_default_addr_size); 998 956 999 957 static void check_obsolete_chosen_interrupt_controller(struct check *c, 1000 958 struct dt_info *dti, ··· 1036 950 1037 951 prop = get_property(chosen, "interrupt-controller"); 1038 952 if (prop) 1039 - FAIL(c, dti, "/chosen has obsolete \"interrupt-controller\" " 1040 - "property"); 953 + FAIL_PROP(c, dti, node, prop, 954 + "/chosen has obsolete \"interrupt-controller\" property"); 1041 955 } 1042 956 WARNING(obsolete_chosen_interrupt_controller, 1043 957 check_obsolete_chosen_interrupt_controller, NULL); 958 + 959 + static void check_chosen_node_is_root(struct check *c, struct dt_info *dti, 960 + struct node *node) 961 + { 962 + if (!streq(node->name, "chosen")) 963 + return; 964 + 965 + if (node->parent != dti->dt) 966 + FAIL(c, dti, node, "chosen node must be at root node"); 967 + } 968 + WARNING(chosen_node_is_root, check_chosen_node_is_root, NULL); 969 + 970 + static void check_chosen_node_bootargs(struct check *c, struct dt_info *dti, 971 + struct node *node) 972 + { 973 + struct property *prop; 974 + 975 + if (!streq(node->name, "chosen")) 976 + return; 977 + 978 + prop = get_property(node, "bootargs"); 979 + if (!prop) 980 + return; 981 + 982 + c->data = prop->name; 983 + check_is_string(c, dti, node); 984 + } 985 + WARNING(chosen_node_bootargs, check_chosen_node_bootargs, NULL); 986 + 987 + static void check_chosen_node_stdout_path(struct check *c, struct dt_info *dti, 988 + struct node *node) 989 + { 990 + struct property *prop; 991 + 992 + if (!streq(node->name, "chosen")) 993 + return; 994 + 995 + prop = get_property(node, "stdout-path"); 996 + if (!prop) { 997 + prop = get_property(node, "linux,stdout-path"); 998 + if (!prop) 999 + return; 1000 + FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead"); 1001 + } 1002 + 1003 + c->data = prop->name; 1004 + check_is_string(c, dti, node); 1005 + } 1006 + WARNING(chosen_node_stdout_path, check_chosen_node_stdout_path, NULL); 1044 1007 1045 1008 struct provider { 1046 1009 const char *prop_name; ··· 1107 972 int cell, cellsize = 0; 1108 973 1109 974 if (prop->val.len % sizeof(cell_t)) { 1110 - FAIL(c, dti, "property '%s' size (%d) is invalid, expected multiple of %zu in node %s", 1111 - prop->name, prop->val.len, sizeof(cell_t), node->fullpath); 975 + FAIL_PROP(c, dti, node, prop, 976 + "property size (%d) is invalid, expected multiple of %zu", 977 + prop->val.len, sizeof(cell_t)); 1112 978 return; 1113 979 } 1114 980 ··· 1140 1004 break; 1141 1005 } 1142 1006 if (!m) 1143 - FAIL(c, dti, "Property '%s', cell %d is not a phandle reference in %s", 1144 - prop->name, cell, node->fullpath); 1007 + FAIL_PROP(c, dti, node, prop, 1008 + "cell %d is not a phandle reference", 1009 + cell); 1145 1010 } 1146 1011 1147 1012 provider_node = get_node_by_phandle(root, phandle); 1148 1013 if (!provider_node) { 1149 - FAIL(c, dti, "Could not get phandle node for %s:%s(cell %d)", 1150 - node->fullpath, prop->name, cell); 1014 + FAIL_PROP(c, dti, node, prop, 1015 + "Could not get phandle node for (cell %d)", 1016 + cell); 1151 1017 break; 1152 1018 } 1153 1019 ··· 1159 1021 } else if (provider->optional) { 1160 1022 cellsize = 0; 1161 1023 } else { 1162 - FAIL(c, dti, "Missing property '%s' in node %s or bad phandle (referred from %s:%s[%d])", 1024 + FAIL(c, dti, node, "Missing property '%s' in node %s or bad phandle (referred from %s[%d])", 1163 1025 provider->cell_name, 1164 1026 provider_node->fullpath, 1165 - node->fullpath, prop->name, cell); 1027 + prop->name, cell); 1166 1028 break; 1167 1029 } 1168 1030 1169 1031 if (prop->val.len < ((cell + cellsize + 1) * sizeof(cell_t))) { 1170 - FAIL(c, dti, "%s property size (%d) too small for cell size %d in %s", 1171 - prop->name, prop->val.len, cellsize, node->fullpath); 1032 + FAIL_PROP(c, dti, node, prop, 1033 + "property size (%d) too small for cell size %d", 1034 + prop->val.len, cellsize); 1172 1035 } 1173 1036 } 1174 1037 } ··· 1205 1066 WARNING_PROPERTY_PHANDLE_CELLS(power_domains, "power-domains", "#power-domain-cells"); 1206 1067 WARNING_PROPERTY_PHANDLE_CELLS(pwms, "pwms", "#pwm-cells"); 1207 1068 WARNING_PROPERTY_PHANDLE_CELLS(resets, "resets", "#reset-cells"); 1208 - WARNING_PROPERTY_PHANDLE_CELLS(sound_dais, "sound-dais", "#sound-dai-cells"); 1069 + WARNING_PROPERTY_PHANDLE_CELLS(sound_dai, "sound-dai", "#sound-dai-cells"); 1209 1070 WARNING_PROPERTY_PHANDLE_CELLS(thermal_sensors, "thermal-sensors", "#thermal-sensor-cells"); 1210 1071 1211 1072 static bool prop_is_gpio(struct property *prop) ··· 1271 1132 if (!streq(str, "gpio")) 1272 1133 continue; 1273 1134 1274 - FAIL(c, dti, "'[*-]gpio' is deprecated, use '[*-]gpios' instead for %s:%s", 1275 - node->fullpath, prop->name); 1135 + FAIL_PROP(c, dti, node, prop, 1136 + "'[*-]gpio' is deprecated, use '[*-]gpios' instead"); 1276 1137 } 1277 1138 1278 1139 } ··· 1306 1167 return; 1307 1168 1308 1169 if (irq_prop->val.len % sizeof(cell_t)) 1309 - FAIL(c, dti, "property '%s' size (%d) is invalid, expected multiple of %zu in node %s", 1310 - irq_prop->name, irq_prop->val.len, sizeof(cell_t), 1311 - node->fullpath); 1170 + FAIL_PROP(c, dti, node, irq_prop, "size (%d) is invalid, expected multiple of %zu", 1171 + irq_prop->val.len, sizeof(cell_t)); 1312 1172 1313 1173 while (parent && !prop) { 1314 1174 if (parent != node && node_is_interrupt_provider(parent)) { ··· 1325 1187 1326 1188 irq_node = get_node_by_phandle(root, phandle); 1327 1189 if (!irq_node) { 1328 - FAIL(c, dti, "Bad interrupt-parent phandle for %s", 1329 - node->fullpath); 1190 + FAIL_PROP(c, dti, parent, prop, "Bad phandle"); 1330 1191 return; 1331 1192 } 1332 1193 if (!node_is_interrupt_provider(irq_node)) 1333 - FAIL(c, dti, 1334 - "Missing interrupt-controller or interrupt-map property in %s", 1335 - irq_node->fullpath); 1194 + FAIL(c, dti, irq_node, 1195 + "Missing interrupt-controller or interrupt-map property"); 1336 1196 1337 1197 break; 1338 1198 } ··· 1339 1203 } 1340 1204 1341 1205 if (!irq_node) { 1342 - FAIL(c, dti, "Missing interrupt-parent for %s", node->fullpath); 1206 + FAIL(c, dti, node, "Missing interrupt-parent"); 1343 1207 return; 1344 1208 } 1345 1209 1346 1210 prop = get_property(irq_node, "#interrupt-cells"); 1347 1211 if (!prop) { 1348 - FAIL(c, dti, "Missing #interrupt-cells in interrupt-parent %s", 1349 - irq_node->fullpath); 1212 + FAIL(c, dti, irq_node, "Missing #interrupt-cells in interrupt-parent"); 1350 1213 return; 1351 1214 } 1352 1215 1353 1216 irq_cells = propval_cell(prop); 1354 1217 if (irq_prop->val.len % (irq_cells * sizeof(cell_t))) { 1355 - FAIL(c, dti, 1356 - "interrupts size is (%d), expected multiple of %d in %s", 1357 - irq_prop->val.len, (int)(irq_cells * sizeof(cell_t)), 1358 - node->fullpath); 1218 + FAIL_PROP(c, dti, node, prop, 1219 + "size is (%d), expected multiple of %d", 1220 + irq_prop->val.len, (int)(irq_cells * sizeof(cell_t))); 1359 1221 } 1360 1222 } 1361 1223 WARNING(interrupts_property, check_interrupts_property, &phandle_references); ··· 1370 1236 1371 1237 &address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell, 1372 1238 &device_type_is_string, &model_is_string, &status_is_string, 1239 + &label_is_string, 1240 + 1241 + &compatible_is_string_list, &names_is_string_list, 1373 1242 1374 1243 &property_name_chars_strict, 1375 1244 &node_name_chars_strict, ··· 1390 1253 &simple_bus_reg, 1391 1254 1392 1255 &avoid_default_addr_size, 1256 + &avoid_unnecessary_addr_size, 1393 1257 &obsolete_chosen_interrupt_controller, 1258 + &chosen_node_is_root, &chosen_node_bootargs, &chosen_node_stdout_path, 1394 1259 1395 1260 &clocks_property, 1396 1261 &cooling_device_property, ··· 1408 1269 &power_domains_property, 1409 1270 &pwms_property, 1410 1271 &resets_property, 1411 - &sound_dais_property, 1272 + &sound_dai_property, 1412 1273 &thermal_sensors_property, 1413 1274 1414 1275 &deprecated_gpio_property, 1415 1276 &gpios_property, 1416 1277 &interrupts_property, 1278 + 1279 + &alias_paths, 1417 1280 1418 1281 &always_fail, 1419 1282 };

+11 -6

scripts/dtc/dtc-parser.y

··· 166 166 { 167 167 $$ = merge_nodes($1, $3); 168 168 } 169 - 169 + | DT_REF nodedef 170 + { 171 + /* 172 + * We rely on the rule being always: 173 + * versioninfo plugindecl memreserves devicetree 174 + * so $-1 is what we want (plugindecl) 175 + */ 176 + if (!($<flags>-1 & DTSF_PLUGIN)) 177 + ERROR(&@2, "Label or path %s not found", $1); 178 + $$ = add_orphan_node(name_node(build_node(NULL, NULL), ""), $2, $1); 179 + } 170 180 | devicetree DT_LABEL DT_REF nodedef 171 181 { 172 182 struct node *target = get_node_by_ref($1, $3); ··· 218 208 219 209 220 210 $$ = $1; 221 - } 222 - | /* empty */ 223 - { 224 - /* build empty node */ 225 - $$ = name_node(build_node(NULL, NULL), ""); 226 211 } 227 212 ; 228 213

+3 -4

scripts/dtc/dtc.c

··· 59 59 } 60 60 61 61 /* Usage related data. */ 62 - #define FDT_VERSION(version) _FDT_VERSION(version) 63 - #define _FDT_VERSION(version) #version 64 62 static const char usage_synopsis[] = "dtc [options] <input file>"; 65 63 static const char usage_short_opts[] = "qI:O:o:V:d:R:S:p:a:fb:i:H:sW:E:@Ahv"; 66 64 static struct option const usage_long_opts[] = { ··· 96 98 "\t\tdts - device tree source text\n" 97 99 "\t\tdtb - device tree blob\n" 98 100 "\t\tasm - assembler source", 99 - "\n\tBlob version to produce, defaults to "FDT_VERSION(DEFAULT_FDT_VERSION)" (for dtb and asm output)", 101 + "\n\tBlob version to produce, defaults to "stringify(DEFAULT_FDT_VERSION)" (for dtb and asm output)", 100 102 "\n\tOutput dependency file", 101 103 "\n\tMake space for <number> reserve map entries (for dtb and asm output)", 102 104 "\n\tMake the blob at least <bytes> long (extra space)", ··· 317 319 dti->boot_cpuid_phys = cmdline_boot_cpuid; 318 320 319 321 fill_fullpaths(dti->dt, ""); 320 - process_checks(force, dti); 321 322 322 323 /* on a plugin, generate by default */ 323 324 if (dti->dtsflags & DTSF_PLUGIN) { 324 325 generate_fixups = 1; 325 326 } 327 + 328 + process_checks(force, dti); 326 329 327 330 if (auto_label_aliases) 328 331 generate_label_tree(dti, "aliases", false);

+6 -5

scripts/dtc/dtc.h

··· 1 - #ifndef _DTC_H 2 - #define _DTC_H 1 + #ifndef DTC_H 2 + #define DTC_H 3 3 4 4 /* 5 5 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005. ··· 67 67 68 68 69 69 #define streq(a, b) (strcmp((a), (b)) == 0) 70 - #define strneq(a, b, n) (strncmp((a), (b), (n)) == 0) 70 + #define strstarts(s, prefix) (strncmp((s), (prefix), strlen(prefix)) == 0) 71 + #define strprefixeq(a, n, b) (strlen(b) == (n) && (memcmp(a, b, n) == 0)) 71 72 72 73 #define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1)) 73 74 ··· 204 203 struct node *name_node(struct node *node, char *name); 205 204 struct node *chain_node(struct node *first, struct node *list); 206 205 struct node *merge_nodes(struct node *old_node, struct node *new_node); 207 - void add_orphan_node(struct node *old_node, struct node *new_node, char *ref); 206 + struct node *add_orphan_node(struct node *old_node, struct node *new_node, char *ref); 208 207 209 208 void add_property(struct node *node, struct property *prop); 210 209 void delete_property_by_name(struct node *node, char *name); ··· 290 289 291 290 struct dt_info *dt_from_fs(const char *dirname); 292 291 293 - #endif /* _DTC_H */ 292 + #endif /* DTC_H */

+1 -1

scripts/dtc/flattree.c

··· 731 731 732 732 plen = strlen(ppath); 733 733 734 - if (!strneq(ppath, cpath, plen)) 734 + if (!strstarts(cpath, ppath)) 735 735 die("Path \"%s\" is not valid as a child of \"%s\"\n", 736 736 cpath, ppath); 737 737

+8 -5

scripts/dtc/libfdt/fdt.c

··· 88 88 || ((offset + len) > fdt_size_dt_struct(fdt))) 89 89 return NULL; 90 90 91 - return _fdt_offset_ptr(fdt, offset); 91 + return fdt_offset_ptr_(fdt, offset); 92 92 } 93 93 94 94 uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset) ··· 123 123 /* skip-name offset, length and value */ 124 124 offset += sizeof(struct fdt_property) - FDT_TAGSIZE 125 125 + fdt32_to_cpu(*lenp); 126 + if (fdt_version(fdt) < 0x10 && fdt32_to_cpu(*lenp) >= 8 && 127 + ((offset - fdt32_to_cpu(*lenp)) % 8) != 0) 128 + offset += 4; 126 129 break; 127 130 128 131 case FDT_END: ··· 144 141 return tag; 145 142 } 146 143 147 - int _fdt_check_node_offset(const void *fdt, int offset) 144 + int fdt_check_node_offset_(const void *fdt, int offset) 148 145 { 149 146 if ((offset < 0) || (offset % FDT_TAGSIZE) 150 147 || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE)) ··· 153 150 return offset; 154 151 } 155 152 156 - int _fdt_check_prop_offset(const void *fdt, int offset) 153 + int fdt_check_prop_offset_(const void *fdt, int offset) 157 154 { 158 155 if ((offset < 0) || (offset % FDT_TAGSIZE) 159 156 || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP)) ··· 168 165 uint32_t tag; 169 166 170 167 if (offset >= 0) 171 - if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0) 168 + if ((nextoffset = fdt_check_node_offset_(fdt, offset)) < 0) 172 169 return nextoffset; 173 170 174 171 do { ··· 230 227 return offset; 231 228 } 232 229 233 - const char *_fdt_find_string(const char *strtab, int tabsize, const char *s) 230 + const char *fdt_find_string_(const char *strtab, int tabsize, const char *s) 234 231 { 235 232 int len = strlen(s) + 1; 236 233 const char *last = strtab + tabsize - len;

+3 -3

scripts/dtc/libfdt/fdt.h

··· 1 - #ifndef _FDT_H 2 - #define _FDT_H 1 + #ifndef FDT_H 2 + #define FDT_H 3 3 /* 4 4 * libfdt - Flat Device Tree manipulation 5 5 * Copyright (C) 2006 David Gibson, IBM Corporation. ··· 108 108 #define FDT_V16_SIZE FDT_V3_SIZE 109 109 #define FDT_V17_SIZE (FDT_V16_SIZE + sizeof(fdt32_t)) 110 110 111 - #endif /* _FDT_H */ 111 + #endif /* FDT_H */

+51

scripts/dtc/libfdt/fdt_overlay.c

··· 1 + /* 2 + * libfdt - Flat Device Tree manipulation 3 + * Copyright (C) 2016 Free Electrons 4 + * Copyright (C) 2016 NextThing Co. 5 + * 6 + * libfdt is dual licensed: you can use it either under the terms of 7 + * the GPL, or the BSD license, at your option. 8 + * 9 + * a) This library is free software; you can redistribute it and/or 10 + * modify it under the terms of the GNU General Public License as 11 + * published by the Free Software Foundation; either version 2 of the 12 + * License, or (at your option) any later version. 13 + * 14 + * This library is distributed in the hope that it will be useful, 15 + * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 + * GNU General Public License for more details. 18 + * 19 + * You should have received a copy of the GNU General Public 20 + * License along with this library; if not, write to the Free 21 + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, 22 + * MA 02110-1301 USA 23 + * 24 + * Alternatively, 25 + * 26 + * b) Redistribution and use in source and binary forms, with or 27 + * without modification, are permitted provided that the following 28 + * conditions are met: 29 + * 30 + * 1. Redistributions of source code must retain the above 31 + * copyright notice, this list of conditions and the following 32 + * disclaimer. 33 + * 2. Redistributions in binary form must reproduce the above 34 + * copyright notice, this list of conditions and the following 35 + * disclaimer in the documentation and/or other materials 36 + * provided with the distribution. 37 + * 38 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 39 + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 40 + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 41 + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 42 + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 43 + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 44 + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 45 + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 46 + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 47 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 48 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 49 + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 50 + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 51 + */ 1 52 #include "libfdt_env.h" 2 53 3 54 #include <fdt.h>

+102 -32

scripts/dtc/libfdt/fdt_ro.c

··· 55 55 56 56 #include "libfdt_internal.h" 57 57 58 - static int _fdt_nodename_eq(const void *fdt, int offset, 58 + static int fdt_nodename_eq_(const void *fdt, int offset, 59 59 const char *s, int len) 60 60 { 61 - const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1); 61 + int olen; 62 + const char *p = fdt_get_name(fdt, offset, &olen); 62 63 63 - if (!p) 64 + if (!p || olen < len) 64 65 /* short match */ 65 66 return 0; 66 67 ··· 81 80 return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset; 82 81 } 83 82 84 - static int _fdt_string_eq(const void *fdt, int stroffset, 83 + static int fdt_string_eq_(const void *fdt, int stroffset, 85 84 const char *s, int len) 86 85 { 87 86 const char *p = fdt_string(fdt, stroffset); ··· 118 117 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size) 119 118 { 120 119 FDT_CHECK_HEADER(fdt); 121 - *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address); 122 - *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size); 120 + *address = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->address); 121 + *size = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->size); 123 122 return 0; 124 123 } 125 124 ··· 127 126 { 128 127 int i = 0; 129 128 130 - while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0) 129 + while (fdt64_to_cpu(fdt_mem_rsv_(fdt, i)->size) != 0) 131 130 i++; 132 131 return i; 133 132 } 134 133 135 - static int _nextprop(const void *fdt, int offset) 134 + static int nextprop_(const void *fdt, int offset) 136 135 { 137 136 uint32_t tag; 138 137 int nextoffset; ··· 167 166 (offset >= 0) && (depth >= 0); 168 167 offset = fdt_next_node(fdt, offset, &depth)) 169 168 if ((depth == 1) 170 - && _fdt_nodename_eq(fdt, offset, name, namelen)) 169 + && fdt_nodename_eq_(fdt, offset, name, namelen)) 171 170 return offset; 172 171 173 172 if (depth < 0) ··· 233 232 234 233 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len) 235 234 { 236 - const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset); 235 + const struct fdt_node_header *nh = fdt_offset_ptr_(fdt, nodeoffset); 236 + const char *nameptr; 237 237 int err; 238 238 239 239 if (((err = fdt_check_header(fdt)) != 0) 240 - || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0)) 240 + || ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0)) 241 241 goto fail; 242 242 243 - if (len) 244 - *len = strlen(nh->name); 243 + nameptr = nh->name; 245 244 246 - return nh->name; 245 + if (fdt_version(fdt) < 0x10) { 246 + /* 247 + * For old FDT versions, match the naming conventions of V16: 248 + * give only the leaf name (after all /). The actual tree 249 + * contents are loosely checked. 250 + */ 251 + const char *leaf; 252 + leaf = strrchr(nameptr, '/'); 253 + if (leaf == NULL) { 254 + err = -FDT_ERR_BADSTRUCTURE; 255 + goto fail; 256 + } 257 + nameptr = leaf+1; 258 + } 259 + 260 + if (len) 261 + *len = strlen(nameptr); 262 + 263 + return nameptr; 247 264 248 265 fail: 249 266 if (len) ··· 273 254 { 274 255 int offset; 275 256 276 - if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0) 257 + if ((offset = fdt_check_node_offset_(fdt, nodeoffset)) < 0) 277 258 return offset; 278 259 279 - return _nextprop(fdt, offset); 260 + return nextprop_(fdt, offset); 280 261 } 281 262 282 263 int fdt_next_property_offset(const void *fdt, int offset) 283 264 { 284 - if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0) 265 + if ((offset = fdt_check_prop_offset_(fdt, offset)) < 0) 285 266 return offset; 286 267 287 - return _nextprop(fdt, offset); 268 + return nextprop_(fdt, offset); 288 269 } 289 270 290 - const struct fdt_property *fdt_get_property_by_offset(const void *fdt, 291 - int offset, 292 - int *lenp) 271 + static const struct fdt_property *fdt_get_property_by_offset_(const void *fdt, 272 + int offset, 273 + int *lenp) 293 274 { 294 275 int err; 295 276 const struct fdt_property *prop; 296 277 297 - if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) { 278 + if ((err = fdt_check_prop_offset_(fdt, offset)) < 0) { 298 279 if (lenp) 299 280 *lenp = err; 300 281 return NULL; 301 282 } 302 283 303 - prop = _fdt_offset_ptr(fdt, offset); 284 + prop = fdt_offset_ptr_(fdt, offset); 304 285 305 286 if (lenp) 306 287 *lenp = fdt32_to_cpu(prop->len); ··· 308 289 return prop; 309 290 } 310 291 311 - const struct fdt_property *fdt_get_property_namelen(const void *fdt, 312 - int offset, 313 - const char *name, 314 - int namelen, int *lenp) 292 + const struct fdt_property *fdt_get_property_by_offset(const void *fdt, 293 + int offset, 294 + int *lenp) 295 + { 296 + /* Prior to version 16, properties may need realignment 297 + * and this API does not work. fdt_getprop_*() will, however. */ 298 + 299 + if (fdt_version(fdt) < 0x10) { 300 + if (lenp) 301 + *lenp = -FDT_ERR_BADVERSION; 302 + return NULL; 303 + } 304 + 305 + return fdt_get_property_by_offset_(fdt, offset, lenp); 306 + } 307 + 308 + static const struct fdt_property *fdt_get_property_namelen_(const void *fdt, 309 + int offset, 310 + const char *name, 311 + int namelen, 312 + int *lenp, 313 + int *poffset) 315 314 { 316 315 for (offset = fdt_first_property_offset(fdt, offset); 317 316 (offset >= 0); 318 317 (offset = fdt_next_property_offset(fdt, offset))) { 319 318 const struct fdt_property *prop; 320 319 321 - if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) { 320 + if (!(prop = fdt_get_property_by_offset_(fdt, offset, lenp))) { 322 321 offset = -FDT_ERR_INTERNAL; 323 322 break; 324 323 } 325 - if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff), 326 - name, namelen)) 324 + if (fdt_string_eq_(fdt, fdt32_to_cpu(prop->nameoff), 325 + name, namelen)) { 326 + if (poffset) 327 + *poffset = offset; 327 328 return prop; 329 + } 328 330 } 329 331 330 332 if (lenp) 331 333 *lenp = offset; 332 334 return NULL; 333 335 } 336 + 337 + 338 + const struct fdt_property *fdt_get_property_namelen(const void *fdt, 339 + int offset, 340 + const char *name, 341 + int namelen, int *lenp) 342 + { 343 + /* Prior to version 16, properties may need realignment 344 + * and this API does not work. fdt_getprop_*() will, however. */ 345 + if (fdt_version(fdt) < 0x10) { 346 + if (lenp) 347 + *lenp = -FDT_ERR_BADVERSION; 348 + return NULL; 349 + } 350 + 351 + return fdt_get_property_namelen_(fdt, offset, name, namelen, lenp, 352 + NULL); 353 + } 354 + 334 355 335 356 const struct fdt_property *fdt_get_property(const void *fdt, 336 357 int nodeoffset, ··· 383 324 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset, 384 325 const char *name, int namelen, int *lenp) 385 326 { 327 + int poffset; 386 328 const struct fdt_property *prop; 387 329 388 - prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp); 330 + prop = fdt_get_property_namelen_(fdt, nodeoffset, name, namelen, lenp, 331 + &poffset); 389 332 if (!prop) 390 333 return NULL; 391 334 335 + /* Handle realignment */ 336 + if (fdt_version(fdt) < 0x10 && (poffset + sizeof(*prop)) % 8 && 337 + fdt32_to_cpu(prop->len) >= 8) 338 + return prop->data + 4; 392 339 return prop->data; 393 340 } 394 341 ··· 403 338 { 404 339 const struct fdt_property *prop; 405 340 406 - prop = fdt_get_property_by_offset(fdt, offset, lenp); 341 + prop = fdt_get_property_by_offset_(fdt, offset, lenp); 407 342 if (!prop) 408 343 return NULL; 409 344 if (namep) 410 345 *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff)); 346 + 347 + /* Handle realignment */ 348 + if (fdt_version(fdt) < 0x10 && (offset + sizeof(*prop)) % 8 && 349 + fdt32_to_cpu(prop->len) >= 8) 350 + return prop->data + 4; 411 351 return prop->data; 412 352 } 413 353

+45 -45

scripts/dtc/libfdt/fdt_rw.c

··· 55 55 56 56 #include "libfdt_internal.h" 57 57 58 - static int _fdt_blocks_misordered(const void *fdt, 59 - int mem_rsv_size, int struct_size) 58 + static int fdt_blocks_misordered_(const void *fdt, 59 + int mem_rsv_size, int struct_size) 60 60 { 61 61 return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8)) 62 62 || (fdt_off_dt_struct(fdt) < ··· 67 67 (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt))); 68 68 } 69 69 70 - static int _fdt_rw_check_header(void *fdt) 70 + static int fdt_rw_check_header_(void *fdt) 71 71 { 72 72 FDT_CHECK_HEADER(fdt); 73 73 74 74 if (fdt_version(fdt) < 17) 75 75 return -FDT_ERR_BADVERSION; 76 - if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry), 76 + if (fdt_blocks_misordered_(fdt, sizeof(struct fdt_reserve_entry), 77 77 fdt_size_dt_struct(fdt))) 78 78 return -FDT_ERR_BADLAYOUT; 79 79 if (fdt_version(fdt) > 17) ··· 84 84 85 85 #define FDT_RW_CHECK_HEADER(fdt) \ 86 86 { \ 87 - int __err; \ 88 - if ((__err = _fdt_rw_check_header(fdt)) != 0) \ 89 - return __err; \ 87 + int err_; \ 88 + if ((err_ = fdt_rw_check_header_(fdt)) != 0) \ 89 + return err_; \ 90 90 } 91 91 92 - static inline int _fdt_data_size(void *fdt) 92 + static inline int fdt_data_size_(void *fdt) 93 93 { 94 94 return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt); 95 95 } 96 96 97 - static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen) 97 + static int fdt_splice_(void *fdt, void *splicepoint, int oldlen, int newlen) 98 98 { 99 99 char *p = splicepoint; 100 - char *end = (char *)fdt + _fdt_data_size(fdt); 100 + char *end = (char *)fdt + fdt_data_size_(fdt); 101 101 102 102 if (((p + oldlen) < p) || ((p + oldlen) > end)) 103 103 return -FDT_ERR_BADOFFSET; ··· 109 109 return 0; 110 110 } 111 111 112 - static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p, 112 + static int fdt_splice_mem_rsv_(void *fdt, struct fdt_reserve_entry *p, 113 113 int oldn, int newn) 114 114 { 115 115 int delta = (newn - oldn) * sizeof(*p); 116 116 int err; 117 - err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p)); 117 + err = fdt_splice_(fdt, p, oldn * sizeof(*p), newn * sizeof(*p)); 118 118 if (err) 119 119 return err; 120 120 fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta); ··· 122 122 return 0; 123 123 } 124 124 125 - static int _fdt_splice_struct(void *fdt, void *p, 125 + static int fdt_splice_struct_(void *fdt, void *p, 126 126 int oldlen, int newlen) 127 127 { 128 128 int delta = newlen - oldlen; 129 129 int err; 130 130 131 - if ((err = _fdt_splice(fdt, p, oldlen, newlen))) 131 + if ((err = fdt_splice_(fdt, p, oldlen, newlen))) 132 132 return err; 133 133 134 134 fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta); ··· 136 136 return 0; 137 137 } 138 138 139 - static int _fdt_splice_string(void *fdt, int newlen) 139 + static int fdt_splice_string_(void *fdt, int newlen) 140 140 { 141 141 void *p = (char *)fdt 142 142 + fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt); 143 143 int err; 144 144 145 - if ((err = _fdt_splice(fdt, p, 0, newlen))) 145 + if ((err = fdt_splice_(fdt, p, 0, newlen))) 146 146 return err; 147 147 148 148 fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen); 149 149 return 0; 150 150 } 151 151 152 - static int _fdt_find_add_string(void *fdt, const char *s) 152 + static int fdt_find_add_string_(void *fdt, const char *s) 153 153 { 154 154 char *strtab = (char *)fdt + fdt_off_dt_strings(fdt); 155 155 const char *p; ··· 157 157 int len = strlen(s) + 1; 158 158 int err; 159 159 160 - p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s); 160 + p = fdt_find_string_(strtab, fdt_size_dt_strings(fdt), s); 161 161 if (p) 162 162 /* found it */ 163 163 return (p - strtab); 164 164 165 165 new = strtab + fdt_size_dt_strings(fdt); 166 - err = _fdt_splice_string(fdt, len); 166 + err = fdt_splice_string_(fdt, len); 167 167 if (err) 168 168 return err; 169 169 ··· 178 178 179 179 FDT_RW_CHECK_HEADER(fdt); 180 180 181 - re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt)); 182 - err = _fdt_splice_mem_rsv(fdt, re, 0, 1); 181 + re = fdt_mem_rsv_w_(fdt, fdt_num_mem_rsv(fdt)); 182 + err = fdt_splice_mem_rsv_(fdt, re, 0, 1); 183 183 if (err) 184 184 return err; 185 185 ··· 190 190 191 191 int fdt_del_mem_rsv(void *fdt, int n) 192 192 { 193 - struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n); 193 + struct fdt_reserve_entry *re = fdt_mem_rsv_w_(fdt, n); 194 194 195 195 FDT_RW_CHECK_HEADER(fdt); 196 196 197 197 if (n >= fdt_num_mem_rsv(fdt)) 198 198 return -FDT_ERR_NOTFOUND; 199 199 200 - return _fdt_splice_mem_rsv(fdt, re, 1, 0); 200 + return fdt_splice_mem_rsv_(fdt, re, 1, 0); 201 201 } 202 202 203 - static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name, 203 + static int fdt_resize_property_(void *fdt, int nodeoffset, const char *name, 204 204 int len, struct fdt_property **prop) 205 205 { 206 206 int oldlen; ··· 210 210 if (!*prop) 211 211 return oldlen; 212 212 213 - if ((err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen), 213 + if ((err = fdt_splice_struct_(fdt, (*prop)->data, FDT_TAGALIGN(oldlen), 214 214 FDT_TAGALIGN(len)))) 215 215 return err; 216 216 ··· 218 218 return 0; 219 219 } 220 220 221 - static int _fdt_add_property(void *fdt, int nodeoffset, const char *name, 221 + static int fdt_add_property_(void *fdt, int nodeoffset, const char *name, 222 222 int len, struct fdt_property **prop) 223 223 { 224 224 int proplen; ··· 226 226 int namestroff; 227 227 int err; 228 228 229 - if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0) 229 + if ((nextoffset = fdt_check_node_offset_(fdt, nodeoffset)) < 0) 230 230 return nextoffset; 231 231 232 - namestroff = _fdt_find_add_string(fdt, name); 232 + namestroff = fdt_find_add_string_(fdt, name); 233 233 if (namestroff < 0) 234 234 return namestroff; 235 235 236 - *prop = _fdt_offset_ptr_w(fdt, nextoffset); 236 + *prop = fdt_offset_ptr_w_(fdt, nextoffset); 237 237 proplen = sizeof(**prop) + FDT_TAGALIGN(len); 238 238 239 - err = _fdt_splice_struct(fdt, *prop, 0, proplen); 239 + err = fdt_splice_struct_(fdt, *prop, 0, proplen); 240 240 if (err) 241 241 return err; 242 242 ··· 260 260 261 261 newlen = strlen(name); 262 262 263 - err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1), 263 + err = fdt_splice_struct_(fdt, namep, FDT_TAGALIGN(oldlen+1), 264 264 FDT_TAGALIGN(newlen+1)); 265 265 if (err) 266 266 return err; ··· 277 277 278 278 FDT_RW_CHECK_HEADER(fdt); 279 279 280 - err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop); 280 + err = fdt_resize_property_(fdt, nodeoffset, name, len, &prop); 281 281 if (err == -FDT_ERR_NOTFOUND) 282 - err = _fdt_add_property(fdt, nodeoffset, name, len, &prop); 282 + err = fdt_add_property_(fdt, nodeoffset, name, len, &prop); 283 283 if (err) 284 284 return err; 285 285 ··· 313 313 prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen); 314 314 if (prop) { 315 315 newlen = len + oldlen; 316 - err = _fdt_splice_struct(fdt, prop->data, 316 + err = fdt_splice_struct_(fdt, prop->data, 317 317 FDT_TAGALIGN(oldlen), 318 318 FDT_TAGALIGN(newlen)); 319 319 if (err) ··· 321 321 prop->len = cpu_to_fdt32(newlen); 322 322 memcpy(prop->data + oldlen, val, len); 323 323 } else { 324 - err = _fdt_add_property(fdt, nodeoffset, name, len, &prop); 324 + err = fdt_add_property_(fdt, nodeoffset, name, len, &prop); 325 325 if (err) 326 326 return err; 327 327 memcpy(prop->data, val, len); ··· 341 341 return len; 342 342 343 343 proplen = sizeof(*prop) + FDT_TAGALIGN(len); 344 - return _fdt_splice_struct(fdt, prop, proplen, 0); 344 + return fdt_splice_struct_(fdt, prop, proplen, 0); 345 345 } 346 346 347 347 int fdt_add_subnode_namelen(void *fdt, int parentoffset, ··· 369 369 tag = fdt_next_tag(fdt, offset, &nextoffset); 370 370 } while ((tag == FDT_PROP) || (tag == FDT_NOP)); 371 371 372 - nh = _fdt_offset_ptr_w(fdt, offset); 372 + nh = fdt_offset_ptr_w_(fdt, offset); 373 373 nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE; 374 374 375 - err = _fdt_splice_struct(fdt, nh, 0, nodelen); 375 + err = fdt_splice_struct_(fdt, nh, 0, nodelen); 376 376 if (err) 377 377 return err; 378 378 ··· 396 396 397 397 FDT_RW_CHECK_HEADER(fdt); 398 398 399 - endoffset = _fdt_node_end_offset(fdt, nodeoffset); 399 + endoffset = fdt_node_end_offset_(fdt, nodeoffset); 400 400 if (endoffset < 0) 401 401 return endoffset; 402 402 403 - return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset), 403 + return fdt_splice_struct_(fdt, fdt_offset_ptr_w_(fdt, nodeoffset), 404 404 endoffset - nodeoffset, 0); 405 405 } 406 406 407 - static void _fdt_packblocks(const char *old, char *new, 407 + static void fdt_packblocks_(const char *old, char *new, 408 408 int mem_rsv_size, int struct_size) 409 409 { 410 410 int mem_rsv_off, struct_off, strings_off; ··· 450 450 return struct_size; 451 451 } 452 452 453 - if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) { 453 + if (!fdt_blocks_misordered_(fdt, mem_rsv_size, struct_size)) { 454 454 /* no further work necessary */ 455 455 err = fdt_move(fdt, buf, bufsize); 456 456 if (err) ··· 478 478 return -FDT_ERR_NOSPACE; 479 479 } 480 480 481 - _fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size); 481 + fdt_packblocks_(fdt, tmp, mem_rsv_size, struct_size); 482 482 memmove(buf, tmp, newsize); 483 483 484 484 fdt_set_magic(buf, FDT_MAGIC); ··· 498 498 499 499 mem_rsv_size = (fdt_num_mem_rsv(fdt)+1) 500 500 * sizeof(struct fdt_reserve_entry); 501 - _fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt)); 502 - fdt_set_totalsize(fdt, _fdt_data_size(fdt)); 501 + fdt_packblocks_(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt)); 502 + fdt_set_totalsize(fdt, fdt_data_size_(fdt)); 503 503 504 504 return 0; 505 505 }

+12 -12

scripts/dtc/libfdt/fdt_sw.c

··· 55 55 56 56 #include "libfdt_internal.h" 57 57 58 - static int _fdt_sw_check_header(void *fdt) 58 + static int fdt_sw_check_header_(void *fdt) 59 59 { 60 60 if (fdt_magic(fdt) != FDT_SW_MAGIC) 61 61 return -FDT_ERR_BADMAGIC; ··· 66 66 #define FDT_SW_CHECK_HEADER(fdt) \ 67 67 { \ 68 68 int err; \ 69 - if ((err = _fdt_sw_check_header(fdt)) != 0) \ 69 + if ((err = fdt_sw_check_header_(fdt)) != 0) \ 70 70 return err; \ 71 71 } 72 72 73 - static void *_fdt_grab_space(void *fdt, size_t len) 73 + static void *fdt_grab_space_(void *fdt, size_t len) 74 74 { 75 75 int offset = fdt_size_dt_struct(fdt); 76 76 int spaceleft; ··· 82 82 return NULL; 83 83 84 84 fdt_set_size_dt_struct(fdt, offset + len); 85 - return _fdt_offset_ptr_w(fdt, offset); 85 + return fdt_offset_ptr_w_(fdt, offset); 86 86 } 87 87 88 88 int fdt_create(void *buf, int bufsize) ··· 174 174 175 175 FDT_SW_CHECK_HEADER(fdt); 176 176 177 - nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen)); 177 + nh = fdt_grab_space_(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen)); 178 178 if (! nh) 179 179 return -FDT_ERR_NOSPACE; 180 180 ··· 189 189 190 190 FDT_SW_CHECK_HEADER(fdt); 191 191 192 - en = _fdt_grab_space(fdt, FDT_TAGSIZE); 192 + en = fdt_grab_space_(fdt, FDT_TAGSIZE); 193 193 if (! en) 194 194 return -FDT_ERR_NOSPACE; 195 195 ··· 197 197 return 0; 198 198 } 199 199 200 - static int _fdt_find_add_string(void *fdt, const char *s) 200 + static int fdt_find_add_string_(void *fdt, const char *s) 201 201 { 202 202 char *strtab = (char *)fdt + fdt_totalsize(fdt); 203 203 const char *p; ··· 205 205 int len = strlen(s) + 1; 206 206 int struct_top, offset; 207 207 208 - p = _fdt_find_string(strtab - strtabsize, strtabsize, s); 208 + p = fdt_find_string_(strtab - strtabsize, strtabsize, s); 209 209 if (p) 210 210 return p - strtab; 211 211 ··· 227 227 228 228 FDT_SW_CHECK_HEADER(fdt); 229 229 230 - nameoff = _fdt_find_add_string(fdt, name); 230 + nameoff = fdt_find_add_string_(fdt, name); 231 231 if (nameoff == 0) 232 232 return -FDT_ERR_NOSPACE; 233 233 234 - prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len)); 234 + prop = fdt_grab_space_(fdt, sizeof(*prop) + FDT_TAGALIGN(len)); 235 235 if (! prop) 236 236 return -FDT_ERR_NOSPACE; 237 237 ··· 265 265 FDT_SW_CHECK_HEADER(fdt); 266 266 267 267 /* Add terminator */ 268 - end = _fdt_grab_space(fdt, sizeof(*end)); 268 + end = fdt_grab_space_(fdt, sizeof(*end)); 269 269 if (! end) 270 270 return -FDT_ERR_NOSPACE; 271 271 *end = cpu_to_fdt32(FDT_END); ··· 281 281 while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) { 282 282 if (tag == FDT_PROP) { 283 283 struct fdt_property *prop = 284 - _fdt_offset_ptr_w(fdt, offset); 284 + fdt_offset_ptr_w_(fdt, offset); 285 285 int nameoff; 286 286 287 287 nameoff = fdt32_to_cpu(prop->nameoff);

+5 -5

scripts/dtc/libfdt/fdt_wip.c

··· 93 93 val, len); 94 94 } 95 95 96 - static void _fdt_nop_region(void *start, int len) 96 + static void fdt_nop_region_(void *start, int len) 97 97 { 98 98 fdt32_t *p; 99 99 ··· 110 110 if (!prop) 111 111 return len; 112 112 113 - _fdt_nop_region(prop, len + sizeof(*prop)); 113 + fdt_nop_region_(prop, len + sizeof(*prop)); 114 114 115 115 return 0; 116 116 } 117 117 118 - int _fdt_node_end_offset(void *fdt, int offset) 118 + int fdt_node_end_offset_(void *fdt, int offset) 119 119 { 120 120 int depth = 0; 121 121 ··· 129 129 { 130 130 int endoffset; 131 131 132 - endoffset = _fdt_node_end_offset(fdt, nodeoffset); 132 + endoffset = fdt_node_end_offset_(fdt, nodeoffset); 133 133 if (endoffset < 0) 134 134 return endoffset; 135 135 136 - _fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0), 136 + fdt_nop_region_(fdt_offset_ptr_w(fdt, nodeoffset, 0), 137 137 endoffset - nodeoffset); 138 138 return 0; 139 139 }

+20 -17

scripts/dtc/libfdt/libfdt.h

··· 1 - #ifndef _LIBFDT_H 2 - #define _LIBFDT_H 1 + #ifndef LIBFDT_H 2 + #define LIBFDT_H 3 3 /* 4 4 * libfdt - Flat Device Tree manipulation 5 5 * Copyright (C) 2006 David Gibson, IBM Corporation. ··· 54 54 #include "libfdt_env.h" 55 55 #include "fdt.h" 56 56 57 - #define FDT_FIRST_SUPPORTED_VERSION 0x10 57 + #define FDT_FIRST_SUPPORTED_VERSION 0x02 58 58 #define FDT_LAST_SUPPORTED_VERSION 0x11 59 59 60 60 /* Error codes: informative error codes */ ··· 225 225 #define fdt_size_dt_strings(fdt) (fdt_get_header(fdt, size_dt_strings)) 226 226 #define fdt_size_dt_struct(fdt) (fdt_get_header(fdt, size_dt_struct)) 227 227 228 - #define __fdt_set_hdr(name) \ 228 + #define fdt_set_hdr_(name) \ 229 229 static inline void fdt_set_##name(void *fdt, uint32_t val) \ 230 230 { \ 231 231 struct fdt_header *fdth = (struct fdt_header *)fdt; \ 232 232 fdth->name = cpu_to_fdt32(val); \ 233 233 } 234 - __fdt_set_hdr(magic); 235 - __fdt_set_hdr(totalsize); 236 - __fdt_set_hdr(off_dt_struct); 237 - __fdt_set_hdr(off_dt_strings); 238 - __fdt_set_hdr(off_mem_rsvmap); 239 - __fdt_set_hdr(version); 240 - __fdt_set_hdr(last_comp_version); 241 - __fdt_set_hdr(boot_cpuid_phys); 242 - __fdt_set_hdr(size_dt_strings); 243 - __fdt_set_hdr(size_dt_struct); 244 - #undef __fdt_set_hdr 234 + fdt_set_hdr_(magic); 235 + fdt_set_hdr_(totalsize); 236 + fdt_set_hdr_(off_dt_struct); 237 + fdt_set_hdr_(off_dt_strings); 238 + fdt_set_hdr_(off_mem_rsvmap); 239 + fdt_set_hdr_(version); 240 + fdt_set_hdr_(last_comp_version); 241 + fdt_set_hdr_(boot_cpuid_phys); 242 + fdt_set_hdr_(size_dt_strings); 243 + fdt_set_hdr_(size_dt_struct); 244 + #undef fdt_set_hdr_ 245 245 246 246 /** 247 247 * fdt_check_header - sanity check a device tree or possible device tree ··· 526 526 * fdt_property structure within the device tree blob at the given 527 527 * offset. If lenp is non-NULL, the length of the property value is 528 528 * also returned, in the integer pointed to by lenp. 529 + * 530 + * Note that this code only works on device tree versions >= 16. fdt_getprop() 531 + * works on all versions. 529 532 * 530 533 * returns: 531 534 * pointer to the structure representing the property ··· 1452 1449 const void *val, int len); 1453 1450 1454 1451 /** 1455 - * fdt_setprop _placeholder - allocate space for a property 1452 + * fdt_setprop_placeholder - allocate space for a property 1456 1453 * @fdt: pointer to the device tree blob 1457 1454 * @nodeoffset: offset of the node whose property to change 1458 1455 * @name: name of the property to change ··· 1899 1896 1900 1897 const char *fdt_strerror(int errval); 1901 1898 1902 - #endif /* _LIBFDT_H */ 1899 + #endif /* LIBFDT_H */

+30 -3

scripts/dtc/libfdt/libfdt_env.h

··· 1 - #ifndef _LIBFDT_ENV_H 2 - #define _LIBFDT_ENV_H 1 + #ifndef LIBFDT_ENV_H 2 + #define LIBFDT_ENV_H 3 3 /* 4 4 * libfdt - Flat Device Tree manipulation 5 5 * Copyright (C) 2006 David Gibson, IBM Corporation. ··· 109 109 #undef CPU_TO_FDT16 110 110 #undef EXTRACT_BYTE 111 111 112 - #endif /* _LIBFDT_ENV_H */ 112 + #ifdef __APPLE__ 113 + #include <AvailabilityMacros.h> 114 + 115 + /* strnlen() is not available on Mac OS < 10.7 */ 116 + # if !defined(MAC_OS_X_VERSION_10_7) || (MAC_OS_X_VERSION_MAX_ALLOWED < \ 117 + MAC_OS_X_VERSION_10_7) 118 + 119 + #define strnlen fdt_strnlen 120 + 121 + /* 122 + * fdt_strnlen: returns the length of a string or max_count - which ever is 123 + * smallest. 124 + * Input 1 string: the string whose size is to be determined 125 + * Input 2 max_count: the maximum value returned by this function 126 + * Output: length of the string or max_count (the smallest of the two) 127 + */ 128 + static inline size_t fdt_strnlen(const char *string, size_t max_count) 129 + { 130 + const char *p = memchr(string, 0, max_count); 131 + return p ? p - string : max_count; 132 + } 133 + 134 + #endif /* !defined(MAC_OS_X_VERSION_10_7) || (MAC_OS_X_VERSION_MAX_ALLOWED < 135 + MAC_OS_X_VERSION_10_7) */ 136 + 137 + #endif /* __APPLE__ */ 138 + 139 + #endif /* LIBFDT_ENV_H */

+16 -16

scripts/dtc/libfdt/libfdt_internal.h

··· 1 - #ifndef _LIBFDT_INTERNAL_H 2 - #define _LIBFDT_INTERNAL_H 1 + #ifndef LIBFDT_INTERNAL_H 2 + #define LIBFDT_INTERNAL_H 3 3 /* 4 4 * libfdt - Flat Device Tree manipulation 5 5 * Copyright (C) 2006 David Gibson, IBM Corporation. ··· 57 57 58 58 #define FDT_CHECK_HEADER(fdt) \ 59 59 { \ 60 - int __err; \ 61 - if ((__err = fdt_check_header(fdt)) != 0) \ 62 - return __err; \ 60 + int err_; \ 61 + if ((err_ = fdt_check_header(fdt)) != 0) \ 62 + return err_; \ 63 63 } 64 64 65 - int _fdt_check_node_offset(const void *fdt, int offset); 66 - int _fdt_check_prop_offset(const void *fdt, int offset); 67 - const char *_fdt_find_string(const char *strtab, int tabsize, const char *s); 68 - int _fdt_node_end_offset(void *fdt, int nodeoffset); 65 + int fdt_check_node_offset_(const void *fdt, int offset); 66 + int fdt_check_prop_offset_(const void *fdt, int offset); 67 + const char *fdt_find_string_(const char *strtab, int tabsize, const char *s); 68 + int fdt_node_end_offset_(void *fdt, int nodeoffset); 69 69 70 - static inline const void *_fdt_offset_ptr(const void *fdt, int offset) 70 + static inline const void *fdt_offset_ptr_(const void *fdt, int offset) 71 71 { 72 72 return (const char *)fdt + fdt_off_dt_struct(fdt) + offset; 73 73 } 74 74 75 - static inline void *_fdt_offset_ptr_w(void *fdt, int offset) 75 + static inline void *fdt_offset_ptr_w_(void *fdt, int offset) 76 76 { 77 - return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset); 77 + return (void *)(uintptr_t)fdt_offset_ptr_(fdt, offset); 78 78 } 79 79 80 - static inline const struct fdt_reserve_entry *_fdt_mem_rsv(const void *fdt, int n) 80 + static inline const struct fdt_reserve_entry *fdt_mem_rsv_(const void *fdt, int n) 81 81 { 82 82 const struct fdt_reserve_entry *rsv_table = 83 83 (const struct fdt_reserve_entry *) ··· 85 85 86 86 return rsv_table + n; 87 87 } 88 - static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n) 88 + static inline struct fdt_reserve_entry *fdt_mem_rsv_w_(void *fdt, int n) 89 89 { 90 - return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n); 90 + return (void *)(uintptr_t)fdt_mem_rsv_(fdt, n); 91 91 } 92 92 93 93 #define FDT_SW_MAGIC (~FDT_MAGIC) 94 94 95 - #endif /* _LIBFDT_INTERNAL_H */ 95 + #endif /* LIBFDT_INTERNAL_H */

+7 -3

scripts/dtc/livetree.c

··· 216 216 return old_node; 217 217 } 218 218 219 - void add_orphan_node(struct node *dt, struct node *new_node, char *ref) 219 + struct node * add_orphan_node(struct node *dt, struct node *new_node, char *ref) 220 220 { 221 221 static unsigned int next_orphan_fragment = 0; 222 222 struct node *node; ··· 236 236 name_node(node, name); 237 237 238 238 add_child(dt, node); 239 + return dt; 239 240 } 240 241 241 242 struct node *chain_node(struct node *first, struct node *list) ··· 508 507 509 508 for_each_child(tree, child) { 510 509 if (p && (strlen(child->name) == p-path) && 511 - strneq(path, child->name, p-path)) 510 + strprefixeq(path, p - path, child->name)) 512 511 return get_node_by_path(child, p+1); 513 512 else if (!p && streq(path, child->name)) 514 513 return child; ··· 541 540 { 542 541 struct node *child, *node; 543 542 544 - assert((phandle != 0) && (phandle != -1)); 543 + if ((phandle == 0) || (phandle == -1)) { 544 + assert(generate_fixups); 545 + return NULL; 546 + } 545 547 546 548 if (tree->phandle == phandle) { 547 549 if (tree->deleted)

-5

scripts/dtc/srcpos.c

··· 209 209 .file = NULL, 210 210 }; 211 211 212 - #define TAB_SIZE 8 213 - 214 212 void srcpos_update(struct srcpos *pos, const char *text, int len) 215 213 { 216 214 int i; ··· 222 224 if (text[i] == '\n') { 223 225 current_srcfile->lineno++; 224 226 current_srcfile->colno = 1; 225 - } else if (text[i] == '\t') { 226 - current_srcfile->colno = 227 - ALIGN(current_srcfile->colno, TAB_SIZE); 228 227 } else { 229 228 current_srcfile->colno++; 230 229 }

+3 -3

scripts/dtc/srcpos.h

··· 17 17 * USA 18 18 */ 19 19 20 - #ifndef _SRCPOS_H_ 21 - #define _SRCPOS_H_ 20 + #ifndef SRCPOS_H 21 + #define SRCPOS_H 22 22 23 23 #include <stdio.h> 24 24 #include <stdbool.h> ··· 114 114 115 115 extern void srcpos_set_line(char *f, int l); 116 116 117 - #endif /* _SRCPOS_H_ */ 117 + #endif /* SRCPOS_H */

+6 -3

scripts/dtc/util.h

··· 1 - #ifndef _UTIL_H 2 - #define _UTIL_H 1 + #ifndef UTIL_H 2 + #define UTIL_H 3 3 4 4 #include <stdarg.h> 5 5 #include <stdbool.h> ··· 34 34 #endif 35 35 36 36 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 37 + 38 + #define stringify(s) stringify_(s) 39 + #define stringify_(s) #s 37 40 38 41 static inline void NORETURN PRINTF(1, 2) die(const char *str, ...) 39 42 { ··· 263 260 case 'V': util_version(); \ 264 261 case '?': usage("unknown option"); 265 262 266 - #endif /* _UTIL_H */ 263 + #endif /* UTIL_H */

+1 -1

scripts/dtc/version_gen.h

··· 1 - #define DTC_VERSION "DTC 1.4.5-gc1e55a55" 1 + #define DTC_VERSION "DTC 1.4.6-gaadd0b65"