2 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2007.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
24 #define TRACE(c, ...) \
26 fprintf(stderr, "=== %s: ", (c)->name); \
27 fprintf(stderr, __VA_ARGS__); \
28 fprintf(stderr, "\n"); \
31 #define TRACE(c, fmt, ...) do { } while (0)
43 typedef void (*check_fn)(struct check *c, struct dt_info *dti, struct node *node);
50 enum checkstatus status;
53 struct check **prereq;
56 #define CHECK_ENTRY(nm_, fn_, d_, w_, e_, ...) \
57 static struct check *nm_##_prereqs[] = { __VA_ARGS__ }; \
58 static struct check nm_ = { \
64 .status = UNCHECKED, \
65 .num_prereqs = ARRAY_SIZE(nm_##_prereqs), \
66 .prereq = nm_##_prereqs, \
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__)
75 static inline void PRINTF(5, 6) check_msg(struct check *c, struct dt_info *dti,
77 struct property *prop,
83 if ((c->warn && (quiet < 1))
84 || (c->error && (quiet < 2))) {
85 fprintf(stderr, "%s: %s (%s): ",
86 strcmp(dti->outname, "-") ? dti->outname : "<stdout>",
87 (c->error) ? "ERROR" : "Warning", c->name);
89 fprintf(stderr, "%s", node->fullpath);
91 fprintf(stderr, ":%s", prop->name);
94 vfprintf(stderr, fmt, ap);
95 fprintf(stderr, "\n");
100 #define FAIL(c, dti, node, ...) \
102 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
103 (c)->status = FAILED; \
104 check_msg((c), dti, node, NULL, __VA_ARGS__); \
107 #define FAIL_PROP(c, dti, node, prop, ...) \
109 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
110 (c)->status = FAILED; \
111 check_msg((c), dti, node, prop, __VA_ARGS__); \
115 static void check_nodes_props(struct check *c, struct dt_info *dti, struct node *node)
119 TRACE(c, "%s", node->fullpath);
123 for_each_child(node, child)
124 check_nodes_props(c, dti, child);
127 static bool run_check(struct check *c, struct dt_info *dti)
129 struct node *dt = dti->dt;
133 assert(!c->inprogress);
135 if (c->status != UNCHECKED)
138 c->inprogress = true;
140 for (i = 0; i < c->num_prereqs; i++) {
141 struct check *prq = c->prereq[i];
142 error = error || run_check(prq, dti);
143 if (prq->status != PASSED) {
145 check_msg(c, dti, NULL, NULL, "Failed prerequisite '%s'",
150 if (c->status != UNCHECKED)
153 check_nodes_props(c, dti, dt);
155 if (c->status == UNCHECKED)
158 TRACE(c, "\tCompleted, status %d", c->status);
161 c->inprogress = false;
162 if ((c->status != PASSED) && (c->error))
168 * Utility check functions
171 /* A check which always fails, for testing purposes only */
172 static inline void check_always_fail(struct check *c, struct dt_info *dti,
175 FAIL(c, dti, node, "always_fail check");
177 CHECK(always_fail, check_always_fail, NULL);
179 static void check_is_string(struct check *c, struct dt_info *dti,
182 struct property *prop;
183 char *propname = c->data;
185 prop = get_property(node, propname);
187 return; /* Not present, assumed ok */
189 if (!data_is_one_string(prop->val))
190 FAIL_PROP(c, dti, node, prop, "property is not a string");
192 #define WARNING_IF_NOT_STRING(nm, propname) \
193 WARNING(nm, check_is_string, (propname))
194 #define ERROR_IF_NOT_STRING(nm, propname) \
195 ERROR(nm, check_is_string, (propname))
197 static void check_is_string_list(struct check *c, struct dt_info *dti,
201 struct property *prop;
202 char *propname = c->data;
205 prop = get_property(node, propname);
207 return; /* Not present, assumed ok */
212 l = strnlen(str, rem);
214 FAIL_PROP(c, dti, node, prop, "property is not a string list");
221 #define WARNING_IF_NOT_STRING_LIST(nm, propname) \
222 WARNING(nm, check_is_string_list, (propname))
223 #define ERROR_IF_NOT_STRING_LIST(nm, propname) \
224 ERROR(nm, check_is_string_list, (propname))
226 static void check_is_cell(struct check *c, struct dt_info *dti,
229 struct property *prop;
230 char *propname = c->data;
232 prop = get_property(node, propname);
234 return; /* Not present, assumed ok */
236 if (prop->val.len != sizeof(cell_t))
237 FAIL_PROP(c, dti, node, prop, "property is not a single cell");
239 #define WARNING_IF_NOT_CELL(nm, propname) \
240 WARNING(nm, check_is_cell, (propname))
241 #define ERROR_IF_NOT_CELL(nm, propname) \
242 ERROR(nm, check_is_cell, (propname))
245 * Structural check functions
248 static void check_duplicate_node_names(struct check *c, struct dt_info *dti,
251 struct node *child, *child2;
253 for_each_child(node, child)
254 for (child2 = child->next_sibling;
256 child2 = child2->next_sibling)
257 if (streq(child->name, child2->name))
258 FAIL(c, dti, node, "Duplicate node name");
260 ERROR(duplicate_node_names, check_duplicate_node_names, NULL);
262 static void check_duplicate_property_names(struct check *c, struct dt_info *dti,
265 struct property *prop, *prop2;
267 for_each_property(node, prop) {
268 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
271 if (streq(prop->name, prop2->name))
272 FAIL_PROP(c, dti, node, prop, "Duplicate property name");
276 ERROR(duplicate_property_names, check_duplicate_property_names, NULL);
278 #define LOWERCASE "abcdefghijklmnopqrstuvwxyz"
279 #define UPPERCASE "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
280 #define DIGITS "0123456789"
281 #define PROPNODECHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-"
282 #define PROPNODECHARSSTRICT LOWERCASE UPPERCASE DIGITS ",-"
284 static void check_node_name_chars(struct check *c, struct dt_info *dti,
287 int n = strspn(node->name, c->data);
289 if (n < strlen(node->name))
290 FAIL(c, dti, node, "Bad character '%c' in node name",
293 ERROR(node_name_chars, check_node_name_chars, PROPNODECHARS "@");
295 static void check_node_name_chars_strict(struct check *c, struct dt_info *dti,
298 int n = strspn(node->name, c->data);
300 if (n < node->basenamelen)
301 FAIL(c, dti, node, "Character '%c' not recommended in node name",
304 CHECK(node_name_chars_strict, check_node_name_chars_strict, PROPNODECHARSSTRICT);
306 static void check_node_name_format(struct check *c, struct dt_info *dti,
309 if (strchr(get_unitname(node), '@'))
310 FAIL(c, dti, node, "multiple '@' characters in node name");
312 ERROR(node_name_format, check_node_name_format, NULL, &node_name_chars);
314 static void check_unit_address_vs_reg(struct check *c, struct dt_info *dti,
317 const char *unitname = get_unitname(node);
318 struct property *prop = get_property(node, "reg");
321 prop = get_property(node, "ranges");
322 if (prop && !prop->val.len)
328 FAIL(c, dti, node, "node has a reg or ranges property, but no unit name");
331 FAIL(c, dti, node, "node has a unit name, but no reg property");
334 WARNING(unit_address_vs_reg, check_unit_address_vs_reg, NULL);
336 static void check_property_name_chars(struct check *c, struct dt_info *dti,
339 struct property *prop;
341 for_each_property(node, prop) {
342 int n = strspn(prop->name, c->data);
344 if (n < strlen(prop->name))
345 FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name",
349 ERROR(property_name_chars, check_property_name_chars, PROPNODECHARS);
351 static void check_property_name_chars_strict(struct check *c,
355 struct property *prop;
357 for_each_property(node, prop) {
358 const char *name = prop->name;
359 int n = strspn(name, c->data);
361 if (n == strlen(prop->name))
364 /* Certain names are whitelisted */
365 if (streq(name, "device_type"))
369 * # is only allowed at the beginning of property names not counting
372 if (name[n] == '#' && ((n == 0) || (name[n-1] == ','))) {
374 n = strspn(name, c->data);
376 if (n < strlen(name))
377 FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name",
381 CHECK(property_name_chars_strict, check_property_name_chars_strict, PROPNODECHARSSTRICT);
383 #define DESCLABEL_FMT "%s%s%s%s%s"
384 #define DESCLABEL_ARGS(node,prop,mark) \
385 ((mark) ? "value of " : ""), \
386 ((prop) ? "'" : ""), \
387 ((prop) ? (prop)->name : ""), \
388 ((prop) ? "' in " : ""), (node)->fullpath
390 static void check_duplicate_label(struct check *c, struct dt_info *dti,
391 const char *label, struct node *node,
392 struct property *prop, struct marker *mark)
394 struct node *dt = dti->dt;
395 struct node *othernode = NULL;
396 struct property *otherprop = NULL;
397 struct marker *othermark = NULL;
399 othernode = get_node_by_label(dt, label);
402 otherprop = get_property_by_label(dt, label, &othernode);
404 othermark = get_marker_label(dt, label, &othernode,
410 if ((othernode != node) || (otherprop != prop) || (othermark != mark))
411 FAIL(c, dti, node, "Duplicate label '%s' on " DESCLABEL_FMT
412 " and " DESCLABEL_FMT,
413 label, DESCLABEL_ARGS(node, prop, mark),
414 DESCLABEL_ARGS(othernode, otherprop, othermark));
417 static void check_duplicate_label_node(struct check *c, struct dt_info *dti,
421 struct property *prop;
423 for_each_label(node->labels, l)
424 check_duplicate_label(c, dti, l->label, node, NULL, NULL);
426 for_each_property(node, prop) {
427 struct marker *m = prop->val.markers;
429 for_each_label(prop->labels, l)
430 check_duplicate_label(c, dti, l->label, node, prop, NULL);
432 for_each_marker_of_type(m, LABEL)
433 check_duplicate_label(c, dti, m->ref, node, prop, m);
436 ERROR(duplicate_label, check_duplicate_label_node, NULL);
438 static cell_t check_phandle_prop(struct check *c, struct dt_info *dti,
439 struct node *node, const char *propname)
441 struct node *root = dti->dt;
442 struct property *prop;
446 prop = get_property(node, propname);
450 if (prop->val.len != sizeof(cell_t)) {
451 FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property",
452 prop->val.len, prop->name);
456 m = prop->val.markers;
457 for_each_marker_of_type(m, REF_PHANDLE) {
458 assert(m->offset == 0);
459 if (node != get_node_by_ref(root, m->ref))
460 /* "Set this node's phandle equal to some
461 * other node's phandle". That's nonsensical
462 * by construction. */ {
463 FAIL(c, dti, node, "%s is a reference to another node",
466 /* But setting this node's phandle equal to its own
467 * phandle is allowed - that means allocate a unique
468 * phandle for this node, even if it's not otherwise
469 * referenced. The value will be filled in later, so
470 * we treat it as having no phandle data for now. */
474 phandle = propval_cell(prop);
476 if ((phandle == 0) || (phandle == -1)) {
477 FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property",
478 phandle, prop->name);
485 static void check_explicit_phandles(struct check *c, struct dt_info *dti,
488 struct node *root = dti->dt;
490 cell_t phandle, linux_phandle;
492 /* Nothing should have assigned phandles yet */
493 assert(!node->phandle);
495 phandle = check_phandle_prop(c, dti, node, "phandle");
497 linux_phandle = check_phandle_prop(c, dti, node, "linux,phandle");
499 if (!phandle && !linux_phandle)
500 /* No valid phandles; nothing further to check */
503 if (linux_phandle && phandle && (phandle != linux_phandle))
504 FAIL(c, dti, node, "mismatching 'phandle' and 'linux,phandle'"
507 if (linux_phandle && !phandle)
508 phandle = linux_phandle;
510 other = get_node_by_phandle(root, phandle);
511 if (other && (other != node)) {
512 FAIL(c, dti, node, "duplicated phandle 0x%x (seen before at %s)",
513 phandle, other->fullpath);
517 node->phandle = phandle;
519 ERROR(explicit_phandles, check_explicit_phandles, NULL);
521 static void check_name_properties(struct check *c, struct dt_info *dti,
524 struct property **pp, *prop = NULL;
526 for (pp = &node->proplist; *pp; pp = &((*pp)->next))
527 if (streq((*pp)->name, "name")) {
533 return; /* No name property, that's fine */
535 if ((prop->val.len != node->basenamelen+1)
536 || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
537 FAIL(c, dti, node, "\"name\" property is incorrect (\"%s\" instead"
538 " of base node name)", prop->val.val);
540 /* The name property is correct, and therefore redundant.
544 data_free(prop->val);
548 ERROR_IF_NOT_STRING(name_is_string, "name");
549 ERROR(name_properties, check_name_properties, NULL, &name_is_string);
552 * Reference fixup functions
555 static void fixup_phandle_references(struct check *c, struct dt_info *dti,
558 struct node *dt = dti->dt;
559 struct property *prop;
561 for_each_property(node, prop) {
562 struct marker *m = prop->val.markers;
563 struct node *refnode;
566 for_each_marker_of_type(m, REF_PHANDLE) {
567 assert(m->offset + sizeof(cell_t) <= prop->val.len);
569 refnode = get_node_by_ref(dt, m->ref);
571 if (!(dti->dtsflags & DTSF_PLUGIN))
572 FAIL(c, dti, node, "Reference to non-existent node or "
573 "label \"%s\"\n", m->ref);
574 else /* mark the entry as unresolved */
575 *((fdt32_t *)(prop->val.val + m->offset)) =
576 cpu_to_fdt32(0xffffffff);
580 phandle = get_node_phandle(dt, refnode);
581 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
583 reference_node(refnode);
587 ERROR(phandle_references, fixup_phandle_references, NULL,
588 &duplicate_node_names, &explicit_phandles);
590 static void fixup_path_references(struct check *c, struct dt_info *dti,
593 struct node *dt = dti->dt;
594 struct property *prop;
596 for_each_property(node, prop) {
597 struct marker *m = prop->val.markers;
598 struct node *refnode;
601 for_each_marker_of_type(m, REF_PATH) {
602 assert(m->offset <= prop->val.len);
604 refnode = get_node_by_ref(dt, m->ref);
606 FAIL(c, dti, node, "Reference to non-existent node or label \"%s\"\n",
611 path = refnode->fullpath;
612 prop->val = data_insert_at_marker(prop->val, m, path,
615 reference_node(refnode);
619 ERROR(path_references, fixup_path_references, NULL, &duplicate_node_names);
621 static void fixup_omit_unused_nodes(struct check *c, struct dt_info *dti,
624 if (node->omit_if_unused && !node->is_referenced)
627 ERROR(omit_unused_nodes, fixup_omit_unused_nodes, NULL, &phandle_references, &path_references);
632 WARNING_IF_NOT_CELL(address_cells_is_cell, "#address-cells");
633 WARNING_IF_NOT_CELL(size_cells_is_cell, "#size-cells");
634 WARNING_IF_NOT_CELL(interrupt_cells_is_cell, "#interrupt-cells");
636 WARNING_IF_NOT_STRING(device_type_is_string, "device_type");
637 WARNING_IF_NOT_STRING(model_is_string, "model");
638 WARNING_IF_NOT_STRING(status_is_string, "status");
639 WARNING_IF_NOT_STRING(label_is_string, "label");
641 WARNING_IF_NOT_STRING_LIST(compatible_is_string_list, "compatible");
643 static void check_names_is_string_list(struct check *c, struct dt_info *dti,
646 struct property *prop;
648 for_each_property(node, prop) {
649 const char *s = strrchr(prop->name, '-');
650 if (!s || !streq(s, "-names"))
653 c->data = prop->name;
654 check_is_string_list(c, dti, node);
657 WARNING(names_is_string_list, check_names_is_string_list, NULL);
659 static void check_alias_paths(struct check *c, struct dt_info *dti,
662 struct property *prop;
664 if (!streq(node->name, "aliases"))
667 for_each_property(node, prop) {
668 if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) {
669 FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)",
673 if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name))
674 FAIL(c, dti, node, "aliases property name must include only lowercase and '-'");
677 WARNING(alias_paths, check_alias_paths, NULL);
679 static void fixup_addr_size_cells(struct check *c, struct dt_info *dti,
682 struct property *prop;
684 node->addr_cells = -1;
685 node->size_cells = -1;
687 prop = get_property(node, "#address-cells");
689 node->addr_cells = propval_cell(prop);
691 prop = get_property(node, "#size-cells");
693 node->size_cells = propval_cell(prop);
695 WARNING(addr_size_cells, fixup_addr_size_cells, NULL,
696 &address_cells_is_cell, &size_cells_is_cell);
698 #define node_addr_cells(n) \
699 (((n)->addr_cells == -1) ? 2 : (n)->addr_cells)
700 #define node_size_cells(n) \
701 (((n)->size_cells == -1) ? 1 : (n)->size_cells)
703 static void check_reg_format(struct check *c, struct dt_info *dti,
706 struct property *prop;
707 int addr_cells, size_cells, entrylen;
709 prop = get_property(node, "reg");
711 return; /* No "reg", that's fine */
714 FAIL(c, dti, node, "Root node has a \"reg\" property");
718 if (prop->val.len == 0)
719 FAIL_PROP(c, dti, node, prop, "property is empty");
721 addr_cells = node_addr_cells(node->parent);
722 size_cells = node_size_cells(node->parent);
723 entrylen = (addr_cells + size_cells) * sizeof(cell_t);
725 if (!entrylen || (prop->val.len % entrylen) != 0)
726 FAIL_PROP(c, dti, node, prop, "property has invalid length (%d bytes) "
727 "(#address-cells == %d, #size-cells == %d)",
728 prop->val.len, addr_cells, size_cells);
730 WARNING(reg_format, check_reg_format, NULL, &addr_size_cells);
732 static void check_ranges_format(struct check *c, struct dt_info *dti,
735 struct property *prop;
736 int c_addr_cells, p_addr_cells, c_size_cells, p_size_cells, entrylen;
738 prop = get_property(node, "ranges");
743 FAIL_PROP(c, dti, node, prop, "Root node has a \"ranges\" property");
747 p_addr_cells = node_addr_cells(node->parent);
748 p_size_cells = node_size_cells(node->parent);
749 c_addr_cells = node_addr_cells(node);
750 c_size_cells = node_size_cells(node);
751 entrylen = (p_addr_cells + c_addr_cells + c_size_cells) * sizeof(cell_t);
753 if (prop->val.len == 0) {
754 if (p_addr_cells != c_addr_cells)
755 FAIL_PROP(c, dti, node, prop, "empty \"ranges\" property but its "
756 "#address-cells (%d) differs from %s (%d)",
757 c_addr_cells, node->parent->fullpath,
759 if (p_size_cells != c_size_cells)
760 FAIL_PROP(c, dti, node, prop, "empty \"ranges\" property but its "
761 "#size-cells (%d) differs from %s (%d)",
762 c_size_cells, node->parent->fullpath,
764 } else if ((prop->val.len % entrylen) != 0) {
765 FAIL_PROP(c, dti, node, prop, "\"ranges\" property has invalid length (%d bytes) "
766 "(parent #address-cells == %d, child #address-cells == %d, "
767 "#size-cells == %d)", prop->val.len,
768 p_addr_cells, c_addr_cells, c_size_cells);
771 WARNING(ranges_format, check_ranges_format, NULL, &addr_size_cells);
773 static const struct bus_type pci_bus = {
777 static void check_pci_bridge(struct check *c, struct dt_info *dti, struct node *node)
779 struct property *prop;
782 prop = get_property(node, "device_type");
783 if (!prop || !streq(prop->val.val, "pci"))
786 node->bus = &pci_bus;
788 if (!strprefixeq(node->name, node->basenamelen, "pci") &&
789 !strprefixeq(node->name, node->basenamelen, "pcie"))
790 FAIL(c, dti, node, "node name is not \"pci\" or \"pcie\"");
792 prop = get_property(node, "ranges");
794 FAIL(c, dti, node, "missing ranges for PCI bridge (or not a bridge)");
796 if (node_addr_cells(node) != 3)
797 FAIL(c, dti, node, "incorrect #address-cells for PCI bridge");
798 if (node_size_cells(node) != 2)
799 FAIL(c, dti, node, "incorrect #size-cells for PCI bridge");
801 prop = get_property(node, "bus-range");
803 FAIL(c, dti, node, "missing bus-range for PCI bridge");
806 if (prop->val.len != (sizeof(cell_t) * 2)) {
807 FAIL_PROP(c, dti, node, prop, "value must be 2 cells");
810 cells = (cell_t *)prop->val.val;
811 if (fdt32_to_cpu(cells[0]) > fdt32_to_cpu(cells[1]))
812 FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell");
813 if (fdt32_to_cpu(cells[1]) > 0xff)
814 FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256");
816 WARNING(pci_bridge, check_pci_bridge, NULL,
817 &device_type_is_string, &addr_size_cells);
819 static void check_pci_device_bus_num(struct check *c, struct dt_info *dti, struct node *node)
821 struct property *prop;
822 unsigned int bus_num, min_bus, max_bus;
825 if (!node->parent || (node->parent->bus != &pci_bus))
828 prop = get_property(node, "reg");
832 cells = (cell_t *)prop->val.val;
833 bus_num = (fdt32_to_cpu(cells[0]) & 0x00ff0000) >> 16;
835 prop = get_property(node->parent, "bus-range");
837 min_bus = max_bus = 0;
839 cells = (cell_t *)prop->val.val;
840 min_bus = fdt32_to_cpu(cells[0]);
841 max_bus = fdt32_to_cpu(cells[0]);
843 if ((bus_num < min_bus) || (bus_num > max_bus))
844 FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)",
845 bus_num, min_bus, max_bus);
847 WARNING(pci_device_bus_num, check_pci_device_bus_num, NULL, ®_format, &pci_bridge);
849 static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct node *node)
851 struct property *prop;
852 const char *unitname = get_unitname(node);
854 unsigned int dev, func, reg;
857 if (!node->parent || (node->parent->bus != &pci_bus))
860 prop = get_property(node, "reg");
862 FAIL(c, dti, node, "missing PCI reg property");
866 cells = (cell_t *)prop->val.val;
867 if (cells[1] || cells[2])
868 FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0");
870 reg = fdt32_to_cpu(cells[0]);
871 dev = (reg & 0xf800) >> 11;
872 func = (reg & 0x700) >> 8;
874 if (reg & 0xff000000)
875 FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space");
876 if (reg & 0x000000ff)
877 FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0");
880 snprintf(unit_addr, sizeof(unit_addr), "%x", dev);
881 if (streq(unitname, unit_addr))
885 snprintf(unit_addr, sizeof(unit_addr), "%x,%x", dev, func);
886 if (streq(unitname, unit_addr))
889 FAIL(c, dti, node, "PCI unit address format error, expected \"%s\"",
892 WARNING(pci_device_reg, check_pci_device_reg, NULL, ®_format, &pci_bridge);
894 static const struct bus_type simple_bus = {
895 .name = "simple-bus",
898 static bool node_is_compatible(struct node *node, const char *compat)
900 struct property *prop;
901 const char *str, *end;
903 prop = get_property(node, "compatible");
907 for (str = prop->val.val, end = str + prop->val.len; str < end;
908 str += strnlen(str, end - str) + 1) {
909 if (strprefixeq(str, end - str, compat))
915 static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
917 if (node_is_compatible(node, "simple-bus"))
918 node->bus = &simple_bus;
920 WARNING(simple_bus_bridge, check_simple_bus_bridge, NULL, &addr_size_cells);
922 static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
924 struct property *prop;
925 const char *unitname = get_unitname(node);
929 cell_t *cells = NULL;
931 if (!node->parent || (node->parent->bus != &simple_bus))
934 prop = get_property(node, "reg");
936 cells = (cell_t *)prop->val.val;
938 prop = get_property(node, "ranges");
939 if (prop && prop->val.len)
940 /* skip of child address */
941 cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
945 if (node->parent->parent && !(node->bus == &simple_bus))
946 FAIL(c, dti, node, "missing or empty reg/ranges property");
950 size = node_addr_cells(node->parent);
952 reg = (reg << 32) | fdt32_to_cpu(*(cells++));
954 snprintf(unit_addr, sizeof(unit_addr), "%"PRIx64, reg);
955 if (!streq(unitname, unit_addr))
956 FAIL(c, dti, node, "simple-bus unit address format error, expected \"%s\"",
959 WARNING(simple_bus_reg, check_simple_bus_reg, NULL, ®_format, &simple_bus_bridge);
961 static void check_unit_address_format(struct check *c, struct dt_info *dti,
964 const char *unitname = get_unitname(node);
966 if (node->parent && node->parent->bus)
972 if (!strncmp(unitname, "0x", 2)) {
973 FAIL(c, dti, node, "unit name should not have leading \"0x\"");
974 /* skip over 0x for next test */
977 if (unitname[0] == '0' && isxdigit(unitname[1]))
978 FAIL(c, dti, node, "unit name should not have leading 0s");
980 WARNING(unit_address_format, check_unit_address_format, NULL,
981 &node_name_format, &pci_bridge, &simple_bus_bridge);
986 static void check_avoid_default_addr_size(struct check *c, struct dt_info *dti,
989 struct property *reg, *ranges;
992 return; /* Ignore root node */
994 reg = get_property(node, "reg");
995 ranges = get_property(node, "ranges");
1000 if (node->parent->addr_cells == -1)
1001 FAIL(c, dti, node, "Relying on default #address-cells value");
1003 if (node->parent->size_cells == -1)
1004 FAIL(c, dti, node, "Relying on default #size-cells value");
1006 WARNING(avoid_default_addr_size, check_avoid_default_addr_size, NULL,
1009 static void check_avoid_unnecessary_addr_size(struct check *c, struct dt_info *dti,
1012 struct property *prop;
1014 bool has_reg = false;
1016 if (!node->parent || node->addr_cells < 0 || node->size_cells < 0)
1019 if (get_property(node, "ranges") || !node->children)
1022 for_each_child(node, child) {
1023 prop = get_property(child, "reg");
1029 FAIL(c, dti, node, "unnecessary #address-cells/#size-cells without \"ranges\" or child \"reg\" property");
1031 WARNING(avoid_unnecessary_addr_size, check_avoid_unnecessary_addr_size, NULL, &avoid_default_addr_size);
1033 static void check_obsolete_chosen_interrupt_controller(struct check *c,
1034 struct dt_info *dti,
1037 struct node *dt = dti->dt;
1038 struct node *chosen;
1039 struct property *prop;
1045 chosen = get_node_by_path(dt, "/chosen");
1049 prop = get_property(chosen, "interrupt-controller");
1051 FAIL_PROP(c, dti, node, prop,
1052 "/chosen has obsolete \"interrupt-controller\" property");
1054 WARNING(obsolete_chosen_interrupt_controller,
1055 check_obsolete_chosen_interrupt_controller, NULL);
1057 static void check_chosen_node_is_root(struct check *c, struct dt_info *dti,
1060 if (!streq(node->name, "chosen"))
1063 if (node->parent != dti->dt)
1064 FAIL(c, dti, node, "chosen node must be at root node");
1066 WARNING(chosen_node_is_root, check_chosen_node_is_root, NULL);
1068 static void check_chosen_node_bootargs(struct check *c, struct dt_info *dti,
1071 struct property *prop;
1073 if (!streq(node->name, "chosen"))
1076 prop = get_property(node, "bootargs");
1080 c->data = prop->name;
1081 check_is_string(c, dti, node);
1083 WARNING(chosen_node_bootargs, check_chosen_node_bootargs, NULL);
1085 static void check_chosen_node_stdout_path(struct check *c, struct dt_info *dti,
1088 struct property *prop;
1090 if (!streq(node->name, "chosen"))
1093 prop = get_property(node, "stdout-path");
1095 prop = get_property(node, "linux,stdout-path");
1098 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead");
1101 c->data = prop->name;
1102 check_is_string(c, dti, node);
1104 WARNING(chosen_node_stdout_path, check_chosen_node_stdout_path, NULL);
1107 const char *prop_name;
1108 const char *cell_name;
1112 static void check_property_phandle_args(struct check *c,
1113 struct dt_info *dti,
1115 struct property *prop,
1116 const struct provider *provider)
1118 struct node *root = dti->dt;
1119 int cell, cellsize = 0;
1121 if (prop->val.len % sizeof(cell_t)) {
1122 FAIL_PROP(c, dti, node, prop,
1123 "property size (%d) is invalid, expected multiple of %zu",
1124 prop->val.len, sizeof(cell_t));
1128 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {
1129 struct node *provider_node;
1130 struct property *cellprop;
1133 phandle = propval_cell_n(prop, cell);
1135 * Some bindings use a cell value 0 or -1 to skip over optional
1136 * entries when each index position has a specific definition.
1138 if (phandle == 0 || phandle == -1) {
1139 /* Give up if this is an overlay with external references */
1140 if (dti->dtsflags & DTSF_PLUGIN)
1147 /* If we have markers, verify the current cell is a phandle */
1148 if (prop->val.markers) {
1149 struct marker *m = prop->val.markers;
1150 for_each_marker_of_type(m, REF_PHANDLE) {
1151 if (m->offset == (cell * sizeof(cell_t)))
1155 FAIL_PROP(c, dti, node, prop,
1156 "cell %d is not a phandle reference",
1160 provider_node = get_node_by_phandle(root, phandle);
1161 if (!provider_node) {
1162 FAIL_PROP(c, dti, node, prop,
1163 "Could not get phandle node for (cell %d)",
1168 cellprop = get_property(provider_node, provider->cell_name);
1170 cellsize = propval_cell(cellprop);
1171 } else if (provider->optional) {
1174 FAIL(c, dti, node, "Missing property '%s' in node %s or bad phandle (referred from %s[%d])",
1175 provider->cell_name,
1176 provider_node->fullpath,
1181 if (prop->val.len < ((cell + cellsize + 1) * sizeof(cell_t))) {
1182 FAIL_PROP(c, dti, node, prop,
1183 "property size (%d) too small for cell size %d",
1184 prop->val.len, cellsize);
1189 static void check_provider_cells_property(struct check *c,
1190 struct dt_info *dti,
1193 struct provider *provider = c->data;
1194 struct property *prop;
1196 prop = get_property(node, provider->prop_name);
1200 check_property_phandle_args(c, dti, node, prop, provider);
1202 #define WARNING_PROPERTY_PHANDLE_CELLS(nm, propname, cells_name, ...) \
1203 static struct provider nm##_provider = { (propname), (cells_name), __VA_ARGS__ }; \
1204 WARNING(nm##_property, check_provider_cells_property, &nm##_provider, &phandle_references);
1206 WARNING_PROPERTY_PHANDLE_CELLS(clocks, "clocks", "#clock-cells");
1207 WARNING_PROPERTY_PHANDLE_CELLS(cooling_device, "cooling-device", "#cooling-cells");
1208 WARNING_PROPERTY_PHANDLE_CELLS(dmas, "dmas", "#dma-cells");
1209 WARNING_PROPERTY_PHANDLE_CELLS(hwlocks, "hwlocks", "#hwlock-cells");
1210 WARNING_PROPERTY_PHANDLE_CELLS(interrupts_extended, "interrupts-extended", "#interrupt-cells");
1211 WARNING_PROPERTY_PHANDLE_CELLS(io_channels, "io-channels", "#io-channel-cells");
1212 WARNING_PROPERTY_PHANDLE_CELLS(iommus, "iommus", "#iommu-cells");
1213 WARNING_PROPERTY_PHANDLE_CELLS(mboxes, "mboxes", "#mbox-cells");
1214 WARNING_PROPERTY_PHANDLE_CELLS(msi_parent, "msi-parent", "#msi-cells", true);
1215 WARNING_PROPERTY_PHANDLE_CELLS(mux_controls, "mux-controls", "#mux-control-cells");
1216 WARNING_PROPERTY_PHANDLE_CELLS(phys, "phys", "#phy-cells");
1217 WARNING_PROPERTY_PHANDLE_CELLS(power_domains, "power-domains", "#power-domain-cells");
1218 WARNING_PROPERTY_PHANDLE_CELLS(pwms, "pwms", "#pwm-cells");
1219 WARNING_PROPERTY_PHANDLE_CELLS(resets, "resets", "#reset-cells");
1220 WARNING_PROPERTY_PHANDLE_CELLS(sound_dai, "sound-dai", "#sound-dai-cells");
1221 WARNING_PROPERTY_PHANDLE_CELLS(thermal_sensors, "thermal-sensors", "#thermal-sensor-cells");
1223 static bool prop_is_gpio(struct property *prop)
1228 * *-gpios and *-gpio can appear in property names,
1229 * so skip over any false matches (only one known ATM)
1231 if (strstr(prop->name, "nr-gpio"))
1234 str = strrchr(prop->name, '-');
1239 if (!(streq(str, "gpios") || streq(str, "gpio")))
1245 static void check_gpios_property(struct check *c,
1246 struct dt_info *dti,
1249 struct property *prop;
1251 /* Skip GPIO hog nodes which have 'gpios' property */
1252 if (get_property(node, "gpio-hog"))
1255 for_each_property(node, prop) {
1256 struct provider provider;
1258 if (!prop_is_gpio(prop))
1261 provider.prop_name = prop->name;
1262 provider.cell_name = "#gpio-cells";
1263 provider.optional = false;
1264 check_property_phandle_args(c, dti, node, prop, &provider);
1268 WARNING(gpios_property, check_gpios_property, NULL, &phandle_references);
1270 static void check_deprecated_gpio_property(struct check *c,
1271 struct dt_info *dti,
1274 struct property *prop;
1276 for_each_property(node, prop) {
1279 if (!prop_is_gpio(prop))
1282 str = strstr(prop->name, "gpio");
1283 if (!streq(str, "gpio"))
1286 FAIL_PROP(c, dti, node, prop,
1287 "'[*-]gpio' is deprecated, use '[*-]gpios' instead");
1291 CHECK(deprecated_gpio_property, check_deprecated_gpio_property, NULL);
1293 static bool node_is_interrupt_provider(struct node *node)
1295 struct property *prop;
1297 prop = get_property(node, "interrupt-controller");
1301 prop = get_property(node, "interrupt-map");
1307 static void check_interrupts_property(struct check *c,
1308 struct dt_info *dti,
1311 struct node *root = dti->dt;
1312 struct node *irq_node = NULL, *parent = node;
1313 struct property *irq_prop, *prop = NULL;
1314 int irq_cells, phandle;
1316 irq_prop = get_property(node, "interrupts");
1320 if (irq_prop->val.len % sizeof(cell_t))
1321 FAIL_PROP(c, dti, node, irq_prop, "size (%d) is invalid, expected multiple of %zu",
1322 irq_prop->val.len, sizeof(cell_t));
1324 while (parent && !prop) {
1325 if (parent != node && node_is_interrupt_provider(parent)) {
1330 prop = get_property(parent, "interrupt-parent");
1332 phandle = propval_cell(prop);
1333 /* Give up if this is an overlay with external references */
1334 if ((phandle == 0 || phandle == -1) &&
1335 (dti->dtsflags & DTSF_PLUGIN))
1338 irq_node = get_node_by_phandle(root, phandle);
1340 FAIL_PROP(c, dti, parent, prop, "Bad phandle");
1343 if (!node_is_interrupt_provider(irq_node))
1344 FAIL(c, dti, irq_node,
1345 "Missing interrupt-controller or interrupt-map property");
1350 parent = parent->parent;
1354 FAIL(c, dti, node, "Missing interrupt-parent");
1358 prop = get_property(irq_node, "#interrupt-cells");
1360 FAIL(c, dti, irq_node, "Missing #interrupt-cells in interrupt-parent");
1364 irq_cells = propval_cell(prop);
1365 if (irq_prop->val.len % (irq_cells * sizeof(cell_t))) {
1366 FAIL_PROP(c, dti, node, prop,
1367 "size is (%d), expected multiple of %d",
1368 irq_prop->val.len, (int)(irq_cells * sizeof(cell_t)));
1371 WARNING(interrupts_property, check_interrupts_property, &phandle_references);
1373 static struct check *check_table[] = {
1374 &duplicate_node_names, &duplicate_property_names,
1375 &node_name_chars, &node_name_format, &property_name_chars,
1376 &name_is_string, &name_properties,
1381 &phandle_references, &path_references,
1384 &address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell,
1385 &device_type_is_string, &model_is_string, &status_is_string,
1388 &compatible_is_string_list, &names_is_string_list,
1390 &property_name_chars_strict,
1391 &node_name_chars_strict,
1393 &addr_size_cells, ®_format, &ranges_format,
1395 &unit_address_vs_reg,
1396 &unit_address_format,
1400 &pci_device_bus_num,
1405 &avoid_default_addr_size,
1406 &avoid_unnecessary_addr_size,
1407 &obsolete_chosen_interrupt_controller,
1408 &chosen_node_is_root, &chosen_node_bootargs, &chosen_node_stdout_path,
1411 &cooling_device_property,
1414 &interrupts_extended_property,
1415 &io_channels_property,
1418 &msi_parent_property,
1419 &mux_controls_property,
1421 &power_domains_property,
1424 &sound_dai_property,
1425 &thermal_sensors_property,
1427 &deprecated_gpio_property,
1429 &interrupts_property,
1436 static void enable_warning_error(struct check *c, bool warn, bool error)
1440 /* Raising level, also raise it for prereqs */
1441 if ((warn && !c->warn) || (error && !c->error))
1442 for (i = 0; i < c->num_prereqs; i++)
1443 enable_warning_error(c->prereq[i], warn, error);
1445 c->warn = c->warn || warn;
1446 c->error = c->error || error;
1449 static void disable_warning_error(struct check *c, bool warn, bool error)
1453 /* Lowering level, also lower it for things this is the prereq
1455 if ((warn && c->warn) || (error && c->error)) {
1456 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
1457 struct check *cc = check_table[i];
1460 for (j = 0; j < cc->num_prereqs; j++)
1461 if (cc->prereq[j] == c)
1462 disable_warning_error(cc, warn, error);
1466 c->warn = c->warn && !warn;
1467 c->error = c->error && !error;
1470 void parse_checks_option(bool warn, bool error, const char *arg)
1473 const char *name = arg;
1476 if ((strncmp(arg, "no-", 3) == 0)
1477 || (strncmp(arg, "no_", 3) == 0)) {
1482 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
1483 struct check *c = check_table[i];
1485 if (streq(c->name, name)) {
1487 enable_warning_error(c, warn, error);
1489 disable_warning_error(c, warn, error);
1494 die("Unrecognized check name \"%s\"\n", name);
1497 void process_checks(bool force, struct dt_info *dti)
1502 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
1503 struct check *c = check_table[i];
1505 if (c->warn || c->error)
1506 error = error || run_check(c, dti);
1511 fprintf(stderr, "ERROR: Input tree has errors, aborting "
1512 "(use -f to force output)\n");
1514 } else if (quiet < 3) {
1515 fprintf(stderr, "Warning: Input tree has errors, "