Lines Matching +full:a +full:- +full:child +full:- +full:node +full:- +full:property
1 // SPDX-License-Identifier: GPL-2.0-or-later
12 fprintf(stderr, "=== %s: ", (c)->name); \
29 typedef void (*check_fn)(struct check *c, struct dt_info *dti, struct node *node);
62 struct node *node,
63 struct property *prop,
71 if (!(c->warn && (quiet < 1)) && !(c->error && (quiet < 2)))
74 if (prop && prop->srcpos)
75 pos = prop->srcpos;
76 else if (node && node->srcpos)
77 pos = node->srcpos;
83 } else if (streq(dti->outname, "-")) {
86 xasprintf(&str, "%s", dti->outname);
90 (c->error) ? "ERROR" : "Warning", c->name);
92 if (node) {
94 xasprintf_append(&str, "%s:%s: ", node->fullpath, prop->name);
96 xasprintf_append(&str, "%s: ", node->fullpath);
106 pos = node->srcpos;
107 while (pos->next) {
108 pos = pos->next;
120 #define FAIL(c, dti, node, ...) \
123 (c)->status = FAILED; \
124 check_msg((c), dti, node, NULL, __VA_ARGS__); \
127 #define FAIL_PROP(c, dti, node, prop, ...) \
130 (c)->status = FAILED; \
131 check_msg((c), dti, node, prop, __VA_ARGS__); \
135 static void check_nodes_props(struct check *c, struct dt_info *dti, struct node *node)
137 struct node *child;
139 TRACE(c, "%s", node->fullpath);
140 if (c->fn)
141 c->fn(c, dti, node);
143 for_each_child(node, child)
144 check_nodes_props(c, dti, child);
157 struct node *dt = dti->dt;
161 assert(!c->inprogress);
163 if (c->status != UNCHECKED)
166 c->inprogress = true;
168 for (i = 0; i < c->num_prereqs; i++) {
169 struct check *prq = c->prereq[i];
171 if (prq->status != PASSED) {
172 c->status = PREREQ;
174 c->prereq[i]->name);
178 if (c->status != UNCHECKED)
183 if (c->status == UNCHECKED)
184 c->status = PASSED;
186 TRACE(c, "\tCompleted, status %d", c->status);
189 c->inprogress = false;
190 if ((c->status != PASSED) && (c->error))
199 /* A check which always fails, for testing purposes only */
201 struct node *node)
203 FAIL(c, dti, node, "always_fail check");
208 struct node *node)
210 struct property *prop;
211 const char *propname = c->data;
213 prop = get_property(node, propname);
217 if (!data_is_one_string(prop->val))
218 FAIL_PROP(c, dti, node, prop, "property is not a string");
226 struct node *node)
229 struct property *prop;
230 const char *propname = c->data;
233 prop = get_property(node, propname);
237 str = prop->val.val;
238 rem = prop->val.len;
242 FAIL_PROP(c, dti, node, prop, "property is not a string list");
245 rem -= l + 1;
255 struct node *node)
257 struct property *prop;
258 const char *propname = c->data;
260 prop = get_property(node, propname);
264 if (prop->val.len != sizeof(cell_t))
265 FAIL_PROP(c, dti, node, prop, "property is not a single cell");
277 struct node *node)
279 struct node *child, *child2;
281 for_each_child(node, child)
282 for (child2 = child->next_sibling;
284 child2 = child2->next_sibling)
285 if (streq(child->name, child2->name))
286 FAIL(c, dti, child2, "Duplicate node name");
291 struct node *node)
293 struct property *prop, *prop2;
295 for_each_property(node, prop) {
296 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
297 if (prop2->deleted)
299 if (streq(prop->name, prop2->name))
300 FAIL_PROP(c, dti, node, prop, "Duplicate property name");
309 #define NODECHARS LOWERCASE UPPERCASE DIGITS ",._+-@"
310 #define PROPCHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-"
311 #define PROPNODECHARSSTRICT LOWERCASE UPPERCASE DIGITS ",-"
314 struct node *node)
316 size_t n = strspn(node->name, c->data);
318 if (n < strlen(node->name))
319 FAIL(c, dti, node, "Bad character '%c' in node name",
320 node->name[n]);
325 struct node *node)
327 int n = strspn(node->name, c->data);
329 if (n < node->basenamelen)
330 FAIL(c, dti, node, "Character '%c' not recommended in node name",
331 node->name[n]);
336 struct node *node)
338 if (strchr(get_unitname(node), '@'))
339 FAIL(c, dti, node, "multiple '@' characters in node name");
345 struct node *node)
347 if (!node->parent)
350 if (get_property(node->parent, node->name)) {
351 FAIL(c, dti, node, "node name and property name conflict");
358 struct node *node)
360 const char *unitname = get_unitname(node);
361 struct property *prop = get_property(node, "reg");
363 if (get_subnode(node, "__overlay__")) {
364 /* HACK: Overlay fragments are a special case */
369 prop = get_property(node, "ranges");
370 if (prop && !prop->val.len)
376 FAIL(c, dti, node, "node has a reg or ranges property, but no unit name");
379 FAIL(c, dti, node, "node has a unit name, but no reg or ranges property");
385 struct node *node)
387 struct property *prop;
389 for_each_property(node, prop) {
390 size_t n = strspn(prop->name, c->data);
392 if (n < strlen(prop->name))
393 FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name",
394 prop->name[n]);
401 struct node *node)
403 struct property *prop;
405 for_each_property(node, prop) {
406 const char *name = prop->name;
407 size_t n = strspn(name, c->data);
409 if (n == strlen(prop->name))
417 * # is only allowed at the beginning of property names not counting
420 if (name[n] == '#' && ((n == 0) || (name[n-1] == ','))) {
422 n = strspn(name, c->data);
425 FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name",
432 #define DESCLABEL_ARGS(node,prop,mark) \
435 ((prop) ? (prop)->name : ""), \
436 ((prop) ? "' in " : ""), (node)->fullpath
439 const char *label, struct node *node,
440 struct property *prop, struct marker *mark)
442 struct node *dt = dti->dt;
443 struct node *othernode = NULL;
444 struct property *otherprop = NULL;
458 if ((othernode != node) || (otherprop != prop) || (othermark != mark))
459 FAIL(c, dti, node, "Duplicate label '%s' on " DESCLABEL_FMT
461 label, DESCLABEL_ARGS(node, prop, mark),
466 struct node *node)
469 struct property *prop;
471 for_each_label(node->labels, l)
472 check_duplicate_label(c, dti, l->label, node, NULL, NULL);
474 for_each_property(node, prop) {
475 struct marker *m = prop->val.markers;
477 for_each_label(prop->labels, l)
478 check_duplicate_label(c, dti, l->label, node, prop, NULL);
481 check_duplicate_label(c, dti, m->ref, node, prop, m);
487 struct node *node, const char *propname)
489 struct node *root = dti->dt;
490 struct property *prop;
494 prop = get_property(node, propname);
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);
504 m = prop->val.markers;
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
511 FAIL(c, dti, node, "%s is a reference to another node",
512 prop->name);
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
525 FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property",
526 phandle, prop->name);
534 struct node *node)
536 struct node *root = dti->dt;
537 struct node *other;
541 assert(!node->phandle);
543 phandle = check_phandle_prop(c, dti, node, "phandle");
545 linux_phandle = check_phandle_prop(c, dti, node, "linux,phandle");
552 FAIL(c, dti, node, "mismatching 'phandle' and 'linux,phandle'"
559 if (other && (other != node)) {
560 FAIL(c, dti, node, "duplicated phandle 0x%x (seen before at %s)",
561 phandle, other->fullpath);
565 node->phandle = phandle;
570 struct node *node)
572 struct property **pp, *prop = NULL;
574 for (pp = &node->proplist; *pp; pp = &((*pp)->next))
575 if (streq((*pp)->name, "name")) {
581 return; /* No name property, that's fine */
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);
588 /* The name property is correct, and therefore redundant.
590 *pp = prop->next;
591 free(prop->name);
592 data_free(prop->val);
604 struct node *node)
606 struct node *dt = dti->dt;
607 struct property *prop;
609 for_each_property(node, prop) {
610 struct marker *m = prop->val.markers;
611 struct node *refnode;
615 assert(m->offset + sizeof(cell_t) <= prop->val.len);
617 refnode = get_node_by_ref(dt, m->ref);
619 if (!(dti->dtsflags & DTSF_PLUGIN))
620 FAIL(c, dti, node, "Reference to non-existent node or "
621 "label \"%s\"\n", m->ref);
623 *((fdt32_t *)(prop->val.val + m->offset)) =
629 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
639 struct node *node)
641 struct node *dt = dti->dt;
642 struct property *prop;
644 for_each_property(node, prop) {
645 struct marker *m = prop->val.markers;
646 struct node *refnode;
650 assert(m->offset <= prop->val.len);
652 refnode = get_node_by_ref(dt, m->ref);
654 FAIL(c, dti, node, "Reference to non-existent node or label \"%s\"\n",
655 m->ref);
659 path = refnode->fullpath;
660 prop->val = data_insert_at_marker(prop->val, m, path,
670 struct node *node)
672 if (generate_symbols && node->labels)
674 if (node->omit_if_unused && !node->is_referenced)
675 delete_node(node);
682 WARNING_IF_NOT_CELL(address_cells_is_cell, "#address-cells");
683 WARNING_IF_NOT_CELL(size_cells_is_cell, "#size-cells");
693 struct node *node)
695 struct property *prop;
697 for_each_property(node, prop) {
698 if (!strends(prop->name, "-names"))
701 c->data = prop->name;
702 check_is_string_list(c, dti, node);
708 struct node *node)
710 struct property *prop;
712 if (!streq(node->name, "aliases"))
715 for_each_property(node, prop) {
716 if (streq(prop->name, "phandle")
717 || streq(prop->name, "linux,phandle")) {
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);
726 if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name))
727 FAIL(c, dti, node, "aliases property name must include only lowercase and '-'");
733 struct node *node)
735 struct property *prop;
737 node->addr_cells = -1;
738 node->size_cells = -1;
740 prop = get_property(node, "#address-cells");
742 node->addr_cells = propval_cell(prop);
744 prop = get_property(node, "#size-cells");
746 node->size_cells = propval_cell(prop);
752 (((n)->addr_cells == -1) ? 2 : (n)->addr_cells)
754 (((n)->size_cells == -1) ? 1 : (n)->size_cells)
757 struct node *node)
759 struct property *prop;
762 prop = get_property(node, "reg");
766 if (!node->parent) {
767 FAIL(c, dti, node, "Root node has a \"reg\" property");
771 if (prop->val.len == 0)
772 FAIL_PROP(c, dti, node, prop, "property is empty");
774 addr_cells = node_addr_cells(node->parent);
775 size_cells = node_size_cells(node->parent);
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);
786 struct node *node)
788 struct property *prop;
790 const char *ranges = c->data;
792 prop = get_property(node, ranges);
796 if (!node->parent) {
797 FAIL_PROP(c, dti, node, prop, "Root node has a \"%s\" property",
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);
808 if (prop->val.len == 0) {
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,
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,
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,
827 WARNING(dma_ranges_format, check_ranges_format, "dma-ranges", &addr_size_cells);
833 static void check_pci_bridge(struct check *c, struct dt_info *dti, struct node *node)
835 struct property *prop;
838 prop = get_property(node, "device_type");
839 if (!prop || !streq(prop->val.val, "pci"))
842 node->bus = &pci_bus;
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\"");
848 prop = get_property(node, "ranges");
850 FAIL(c, dti, node, "missing ranges for PCI bridge (or not a bridge)");
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");
857 prop = get_property(node, "bus-range");
861 if (prop->val.len != (sizeof(cell_t) * 2)) {
862 FAIL_PROP(c, dti, node, prop, "value must be 2 cells");
865 cells = (cell_t *)prop->val.val;
867 FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell");
869 FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256");
874 static void check_pci_device_bus_num(struct check *c, struct dt_info *dti, struct node *node)
876 struct property *prop;
880 if (!node->parent || (node->parent->bus != &pci_bus))
883 prop = get_property(node, "reg");
887 cells = (cell_t *)prop->val.val;
890 prop = get_property(node->parent, "bus-range");
894 cells = (cell_t *)prop->val.val;
899 FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)",
904 static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct node *node)
906 struct property *prop;
907 const char *unitname = get_unitname(node);
912 if (!node->parent || (node->parent->bus != &pci_bus))
915 prop = get_property(node, "reg");
919 cells = (cell_t *)prop->val.val;
921 FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0");
928 FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space");
930 FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0");
942 FAIL(c, dti, node, "PCI unit address format error, expected \"%s\"",
948 .name = "simple-bus",
951 static bool node_is_compatible(struct node *node, const char *compat)
953 struct property *prop;
956 prop = get_property(node, "compatible");
960 for (str = prop->val.val, end = str + prop->val.len; str < end;
961 str += strnlen(str, end - str) + 1) {
968 static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
970 if (node_is_compatible(node, "simple-bus"))
971 node->bus = &simple_bus;
976 static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
978 struct property *prop;
979 const char *unitname = get_unitname(node);
985 if (!node->parent || (node->parent->bus != &simple_bus))
988 prop = get_property(node, "reg");
990 cells = (cell_t *)prop->val.val;
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);
999 if (node->parent->parent && !(node->bus == &simple_bus))
1000 FAIL(c, dti, node, "missing or empty reg/ranges property");
1004 size = node_addr_cells(node->parent);
1005 while (size--)
1010 FAIL(c, dti, node, "simple-bus unit address format error, expected \"%s\"",
1016 .name = "i2c-bus",
1019 static void check_i2c_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
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"))
1030 node->bus = &i2c_bus;
1034 if (!node->children)
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");
1048 static void check_i2c_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
1050 struct property *prop;
1051 const char *unitname = get_unitname(node);
1057 if (!node->parent || (node->parent->bus != &i2c_bus))
1060 prop = get_property(node, "reg");
1062 cells = (cell_t *)prop->val.val;
1065 FAIL(c, dti, node, "missing or empty reg property");
1074 FAIL(c, dti, node, "I2C bus unit address format error, expected \"%s\"",
1077 for (len = prop->val.len; len > 0; len -= 4) {
1084 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 10-bits, got \"0x%x\"",
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",
1094 .name = "spi-bus",
1097 static void check_spi_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
1101 if (strprefixeq(node->name, node->basenamelen, "spi")) {
1102 node->bus = &spi_bus;
1104 /* Try to detect SPI buses which don't have proper node name */
1105 struct node *child;
1107 if (node_addr_cells(node) != 1 || node_size_cells(node) != 0)
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;
1118 if (node->bus == &spi_bus)
1122 if (node->bus == &spi_bus && get_property(node, "reg"))
1123 FAIL(c, dti, node, "node name for SPI buses should be 'spi'");
1125 if (node->bus != &spi_bus || !node->children)
1128 if (get_property(node, "spi-slave"))
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");
1138 static void check_spi_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
1140 struct property *prop;
1141 const char *unitname = get_unitname(node);
1146 if (!node->parent || (node->parent->bus != &spi_bus))
1149 if (get_property(node->parent, "spi-slave"))
1152 prop = get_property(node, "reg");
1154 cells = (cell_t *)prop->val.val;
1157 FAIL(c, dti, node, "missing or empty reg property");
1164 FAIL(c, dti, node, "SPI bus unit address format error, expected \"%s\"",
1170 struct node *node)
1172 const char *unitname = get_unitname(node);
1174 if (node->parent && node->parent->bus)
1181 FAIL(c, dti, node, "unit name should not have leading \"0x\"");
1186 FAIL(c, dti, node, "unit name should not have leading 0s");
1195 struct node *node)
1197 struct property *reg, *ranges;
1199 if (!node->parent)
1200 return; /* Ignore root node */
1202 reg = get_property(node, "reg");
1203 ranges = get_property(node, "ranges");
1208 if (node->parent->addr_cells == -1)
1209 FAIL(c, dti, node, "Relying on default #address-cells value");
1211 if (node->parent->size_cells == -1)
1212 FAIL(c, dti, node, "Relying on default #size-cells value");
1218 struct node *node)
1220 struct node *child;
1222 if (!node->parent || node->addr_cells < 0 || node->size_cells < 0)
1225 if (get_property(node, "ranges") || get_property(node, "dma-ranges") || !node->children)
1228 for_each_child(node, child) {
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
1234 * child nodes then make #address-cells/#size-cells necessary:
1236 if (get_property(child, "reg") || get_property(child, "ranges"))
1240 FAIL(c, dti, node, "unnecessary #address-cells/#size-cells without \"ranges\", \"dma-ranges\" or child \"reg\" or \"ranges\" property");
1244 static bool node_is_disabled(struct node *node)
1246 struct property *prop;
1248 prop = get_property(node, "status");
1250 char *str = prop->val.val;
1260 struct node *node,
1263 struct node *childa;
1265 if (node->addr_cells < 0 || node->size_cells < 0)
1268 if (!node->children)
1271 for_each_child(node, childa) {
1272 struct node *childb;
1281 for_each_child(node, childb) {
1290 FAIL(c, dti, childb, "duplicate unit-address (also used in node %s)", childa->fullpath);
1296 struct node *node)
1298 check_unique_unit_address_common(c, dti, node, false);
1303 struct node *node)
1305 check_unique_unit_address_common(c, dti, node, true);
1312 struct node *node)
1314 struct node *dt = dti->dt;
1315 struct node *chosen;
1316 struct property *prop;
1318 if (node != dt)
1326 prop = get_property(chosen, "interrupt-controller");
1328 FAIL_PROP(c, dti, node, prop,
1329 "/chosen has obsolete \"interrupt-controller\" property");
1335 struct node *node)
1337 if (!streq(node->name, "chosen"))
1340 if (node->parent != dti->dt)
1341 FAIL(c, dti, node, "chosen node must be at root node");
1346 struct node *node)
1348 struct property *prop;
1350 if (!streq(node->name, "chosen"))
1353 prop = get_property(node, "bootargs");
1357 c->data = prop->name;
1358 check_is_string(c, dti, node);
1363 struct node *node)
1365 struct property *prop;
1367 if (!streq(node->name, "chosen"))
1370 prop = get_property(node, "stdout-path");
1372 prop = get_property(node, "linux,stdout-path");
1375 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead");
1378 c->data = prop->name;
1379 check_is_string(c, dti, node);
1391 struct node *node,
1392 struct property *prop,
1395 struct node *root = dti->dt;
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));
1405 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {
1406 struct node *provider_node;
1407 struct property *cellprop;
1413 * Some bindings use a cell value 0 or -1 to skip over optional
1414 * entries when each index position has a specific definition.
1418 if (dti->dtsflags & DTSF_PLUGIN)
1425 /* If we have markers, verify the current cell is a phandle */
1426 if (prop->val.markers) {
1427 struct marker *m = prop->val.markers;
1429 if (m->offset == (cell * sizeof(cell_t)))
1433 FAIL_PROP(c, dti, node, prop,
1434 "cell %d is not a phandle reference",
1440 FAIL_PROP(c, dti, node, prop,
1441 "Could not get phandle node for (cell %d)",
1446 cellprop = get_property(provider_node, provider->cell_name);
1449 } else if (provider->optional) {
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);
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);
1471 struct node *node)
1473 const struct provider *provider = c->data;
1474 struct property *prop;
1476 prop = get_property(node, provider->prop_name);
1480 check_property_phandle_args(c, dti, node, prop, provider);
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");
1504 static bool prop_is_gpio(struct property *prop)
1507 * *-gpios and *-gpio can appear in property names,
1510 if (strends(prop->name, ",nr-gpios"))
1513 return strends(prop->name, "-gpios") ||
1514 streq(prop->name, "gpios") ||
1515 strends(prop->name, "-gpio") ||
1516 streq(prop->name, "gpio");
1521 struct node *node)
1523 struct property *prop;
1525 /* Skip GPIO hog nodes which have 'gpios' property */
1526 if (get_property(node, "gpio-hog"))
1529 for_each_property(node, prop) {
1535 provider.prop_name = prop->name;
1536 provider.cell_name = "#gpio-cells";
1538 check_property_phandle_args(c, dti, node, prop, &provider);
1546 struct node *node)
1548 struct property *prop;
1550 for_each_property(node, prop) {
1554 if (!strends(prop->name, "gpio"))
1557 FAIL_PROP(c, dti, node, prop,
1558 "'[*-]gpio' is deprecated, use '[*-]gpios' instead");
1564 static bool node_is_interrupt_provider(struct node *node)
1566 struct property *prop;
1568 prop = get_property(node, "interrupt-controller");
1572 prop = get_property(node, "interrupt-map");
1581 struct node *node)
1583 struct property *prop;
1584 bool irq_provider = node_is_interrupt_provider(node);
1586 prop = get_property(node, "#interrupt-cells");
1588 FAIL(c, dti, node,
1589 "Missing '#interrupt-cells' in interrupt provider");
1594 FAIL(c, dti, node,
1595 "'#interrupt-cells' found, but node is not an interrupt provider");
1603 struct node *node)
1605 struct node *root = dti->dt;
1606 struct property *prop, *irq_map_prop;
1609 irq_map_prop = get_property(node, "interrupt-map");
1613 if (node->addr_cells < 0) {
1614 FAIL(c, dti, node,
1615 "Missing '#address-cells' in interrupt-map provider");
1618 cellsize = node_addr_cells(node);
1619 cellsize += propval_cell(get_property(node, "#interrupt-cells"));
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));
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));
1634 map_cells = irq_map_prop->val.len / sizeof(cell_t);
1636 struct node *provider_node;
1637 struct property *cellprop;
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));
1652 if (!(dti->dtsflags & DTSF_PLUGIN))
1653 FAIL_PROP(c, dti, node, irq_map_prop,
1654 "Cell %zu is not a phandle(%d)",
1661 FAIL_PROP(c, dti, node, irq_map_prop,
1662 "Could not get phandle(%d) node for (cell %zu)",
1667 cellprop = get_property(provider_node, "#interrupt-cells");
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);
1676 cellprop = get_property(provider_node, "#address-cells");
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);
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));
1695 struct node *node)
1697 struct node *root = dti->dt;
1698 struct node *irq_node = NULL, *parent = node;
1699 struct property *irq_prop, *prop = NULL;
1702 irq_prop = get_property(node, "interrupts");
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));
1711 if (parent != node && node_is_interrupt_provider(parent)) {
1716 prop = get_property(parent, "interrupt-parent");
1722 if (dti->dtsflags & DTSF_PLUGIN)
1735 "Missing interrupt-controller or interrupt-map property");
1740 parent = parent->parent;
1744 FAIL(c, dti, node, "Missing interrupt-parent");
1748 prop = get_property(irq_node, "#interrupt-cells");
1755 if (!is_multiple_of(irq_prop->val.len, irq_cells * sizeof(cell_t))) {
1756 FAIL_PROP(c, dti, node, prop,
1758 irq_prop->val.len, (int)(irq_cells * sizeof(cell_t)));
1764 .name = "graph-port",
1768 .name = "graph-ports",
1772 struct node *node)
1774 struct node *child;
1776 for_each_child(node, child) {
1777 if (!(strprefixeq(child->name, child->basenamelen, "endpoint") ||
1778 get_property(child, "remote-endpoint")))
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);
1786 node->bus = &graph_port_bus;
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;
1800 struct node *node)
1803 const char *unitname = get_unitname(node);
1804 struct property *prop;
1806 prop = get_property(node, "reg");
1810 if (!(prop->val.val && prop->val.len == sizeof(cell_t))) {
1811 FAIL(c, dti, node, "graph node malformed 'reg' property");
1817 FAIL(c, dti, node, "graph node unit address error, expected \"%s\"",
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);
1831 struct node *node)
1833 if (node->bus != &graph_port_bus)
1836 check_graph_reg(c, dti, node);
1839 if (dti->dtsflags & DTSF_PLUGIN)
1842 if (!strprefixeq(node->name, node->basenamelen, "port"))
1843 FAIL(c, dti, node, "graph port node name should be 'port'");
1847 static struct node *get_remote_endpoint(struct check *c, struct dt_info *dti,
1848 struct node *endpoint)
1851 struct node *node;
1852 struct property *prop;
1854 prop = get_property(endpoint, "remote-endpoint");
1863 node = get_node_by_phandle(dti->dt, phandle);
1864 if (!node)
1867 return node;
1871 struct node *node)
1873 struct node *remote_node;
1875 if (!node->parent || node->parent->bus != &graph_port_bus)
1878 check_graph_reg(c, dti, node);
1881 if (dti->dtsflags & DTSF_PLUGIN)
1884 if (!strprefixeq(node->name, node->basenamelen, "endpoint"))
1885 FAIL(c, dti, node, "graph endpoint node name should be 'endpoint'");
1887 remote_node = get_remote_endpoint(c, dti, node);
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);
1898 struct node *node)
1901 struct node *child;
1903 if (node->bus != &graph_ports_bus && node->bus != &graph_port_bus)
1906 for_each_child(node, child) {
1907 struct property *prop = get_property(child, "reg");
1909 /* No error if we have any non-zero unit address */
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);
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);
2022 c->warn = c->warn || warn;
2023 c->error = c->error || error;
2032 if ((warn && c->warn) || (error && c->error)) {
2037 for (j = 0; j < cc->num_prereqs; j++)
2038 if (cc->prereq[j] == c)
2043 c->warn = c->warn && !warn;
2044 c->error = c->error && !error;
2053 if ((strncmp(arg, "no-", 3) == 0)
2062 if (streq(c->name, name)) {
2082 if (c->warn || c->error)
2089 "(use -f to force output)\n");