112869ecdSRob Herring // SPDX-License-Identifier: GPL-2.0-or-later
29fffb55fSDavid Gibson /*
39fffb55fSDavid Gibson * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2007.
49fffb55fSDavid Gibson */
59fffb55fSDavid Gibson
69fffb55fSDavid Gibson #include "dtc.h"
7c2e7075cSRob Herring #include "srcpos.h"
89fffb55fSDavid Gibson
99fffb55fSDavid Gibson #ifdef TRACE_CHECKS
109fffb55fSDavid Gibson #define TRACE(c, ...) \
119fffb55fSDavid Gibson do { \
129fffb55fSDavid Gibson fprintf(stderr, "=== %s: ", (c)->name); \
139fffb55fSDavid Gibson fprintf(stderr, __VA_ARGS__); \
149fffb55fSDavid Gibson fprintf(stderr, "\n"); \
159fffb55fSDavid Gibson } while (0)
169fffb55fSDavid Gibson #else
179fffb55fSDavid Gibson #define TRACE(c, fmt, ...) do { } while (0)
189fffb55fSDavid Gibson #endif
199fffb55fSDavid Gibson
209fffb55fSDavid Gibson enum checkstatus {
219fffb55fSDavid Gibson UNCHECKED = 0,
229fffb55fSDavid Gibson PREREQ,
239fffb55fSDavid Gibson PASSED,
249fffb55fSDavid Gibson FAILED,
259fffb55fSDavid Gibson };
269fffb55fSDavid Gibson
279fffb55fSDavid Gibson struct check;
289fffb55fSDavid Gibson
296f05afcbSRob Herring typedef void (*check_fn)(struct check *c, struct dt_info *dti, struct node *node);
309fffb55fSDavid Gibson
319fffb55fSDavid Gibson struct check {
329fffb55fSDavid Gibson const char *name;
336f05afcbSRob Herring check_fn fn;
349fffb55fSDavid Gibson void *data;
35cd296721SStephen Warren bool warn, error;
369fffb55fSDavid Gibson enum checkstatus status;
3747605971SRob Herring bool inprogress;
389fffb55fSDavid Gibson int num_prereqs;
399fffb55fSDavid Gibson struct check **prereq;
409fffb55fSDavid Gibson };
419fffb55fSDavid Gibson
429130ba88SRob Herring #define CHECK_ENTRY(nm_, fn_, d_, w_, e_, ...) \
439130ba88SRob Herring static struct check *nm_##_prereqs[] = { __VA_ARGS__ }; \
449130ba88SRob Herring static struct check nm_ = { \
459130ba88SRob Herring .name = #nm_, \
469130ba88SRob Herring .fn = (fn_), \
479130ba88SRob Herring .data = (d_), \
489130ba88SRob Herring .warn = (w_), \
499130ba88SRob Herring .error = (e_), \
509fffb55fSDavid Gibson .status = UNCHECKED, \
519130ba88SRob Herring .num_prereqs = ARRAY_SIZE(nm_##_prereqs), \
529130ba88SRob Herring .prereq = nm_##_prereqs, \
539fffb55fSDavid Gibson };
549130ba88SRob Herring #define WARNING(nm_, fn_, d_, ...) \
559130ba88SRob Herring CHECK_ENTRY(nm_, fn_, d_, true, false, __VA_ARGS__)
569130ba88SRob Herring #define ERROR(nm_, fn_, d_, ...) \
579130ba88SRob Herring CHECK_ENTRY(nm_, fn_, d_, false, true, __VA_ARGS__)
589130ba88SRob Herring #define CHECK(nm_, fn_, d_, ...) \
599130ba88SRob Herring CHECK_ENTRY(nm_, fn_, d_, false, false, __VA_ARGS__)
609fffb55fSDavid Gibson
check_msg(struct check * c,struct dt_info * dti,struct node * node,struct property * prop,const char * fmt,...)619130ba88SRob Herring static inline void PRINTF(5, 6) check_msg(struct check *c, struct dt_info *dti,
629130ba88SRob Herring struct node *node,
639130ba88SRob Herring struct property *prop,
6489d12310SRob Herring const char *fmt, ...)
659fffb55fSDavid Gibson {
669fffb55fSDavid Gibson va_list ap;
67c2e7075cSRob Herring char *str = NULL;
68c2e7075cSRob Herring struct srcpos *pos = NULL;
69c2e7075cSRob Herring char *file_str;
709fffb55fSDavid Gibson
71c2e7075cSRob Herring if (!(c->warn && (quiet < 1)) && !(c->error && (quiet < 2)))
72c2e7075cSRob Herring return;
73c2e7075cSRob Herring
74c2e7075cSRob Herring if (prop && prop->srcpos)
75c2e7075cSRob Herring pos = prop->srcpos;
76c2e7075cSRob Herring else if (node && node->srcpos)
77c2e7075cSRob Herring pos = node->srcpos;
78c2e7075cSRob Herring
79c2e7075cSRob Herring if (pos) {
80c2e7075cSRob Herring file_str = srcpos_string(pos);
81c2e7075cSRob Herring xasprintf(&str, "%s", file_str);
82c2e7075cSRob Herring free(file_str);
83c2e7075cSRob Herring } else if (streq(dti->outname, "-")) {
84c2e7075cSRob Herring xasprintf(&str, "<stdout>");
85c2e7075cSRob Herring } else {
86c2e7075cSRob Herring xasprintf(&str, "%s", dti->outname);
87c2e7075cSRob Herring }
88c2e7075cSRob Herring
89c2e7075cSRob Herring xasprintf_append(&str, ": %s (%s): ",
90cd296721SStephen Warren (c->error) ? "ERROR" : "Warning", c->name);
91c2e7075cSRob Herring
929130ba88SRob Herring if (node) {
939130ba88SRob Herring if (prop)
94c2e7075cSRob Herring xasprintf_append(&str, "%s:%s: ", node->fullpath, prop->name);
95c2e7075cSRob Herring else
96c2e7075cSRob Herring xasprintf_append(&str, "%s: ", node->fullpath);
979130ba88SRob Herring }
98c2e7075cSRob Herring
99c2e7075cSRob Herring va_start(ap, fmt);
100c2e7075cSRob Herring xavsprintf_append(&str, fmt, ap);
10147605971SRob Herring va_end(ap);
102c2e7075cSRob Herring
103c2e7075cSRob Herring xasprintf_append(&str, "\n");
104c2e7075cSRob Herring
105c2e7075cSRob Herring if (!prop && pos) {
106c2e7075cSRob Herring pos = node->srcpos;
107c2e7075cSRob Herring while (pos->next) {
108c2e7075cSRob Herring pos = pos->next;
109c2e7075cSRob Herring
110c2e7075cSRob Herring file_str = srcpos_string(pos);
111c2e7075cSRob Herring xasprintf_append(&str, " also defined at %s\n", file_str);
112c2e7075cSRob Herring free(file_str);
113c2e7075cSRob Herring }
114c2e7075cSRob Herring }
115c2e7075cSRob Herring
116c2e7075cSRob Herring fputs(str, stderr);
117cd296721SStephen Warren }
1189fffb55fSDavid Gibson
1199130ba88SRob Herring #define FAIL(c, dti, node, ...) \
1209fffb55fSDavid Gibson do { \
1219fffb55fSDavid Gibson TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
1229fffb55fSDavid Gibson (c)->status = FAILED; \
1239130ba88SRob Herring check_msg((c), dti, node, NULL, __VA_ARGS__); \
1249fffb55fSDavid Gibson } while (0)
1259fffb55fSDavid Gibson
1269130ba88SRob Herring #define FAIL_PROP(c, dti, node, prop, ...) \
1279130ba88SRob Herring do { \
1289130ba88SRob Herring TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
1299130ba88SRob Herring (c)->status = FAILED; \
1309130ba88SRob Herring check_msg((c), dti, node, prop, __VA_ARGS__); \
1319130ba88SRob Herring } while (0)
1329130ba88SRob Herring
1339130ba88SRob Herring
check_nodes_props(struct check * c,struct dt_info * dti,struct node * node)1346f05afcbSRob Herring static void check_nodes_props(struct check *c, struct dt_info *dti, struct node *node)
1359fffb55fSDavid Gibson {
1369fffb55fSDavid Gibson struct node *child;
1379fffb55fSDavid Gibson
1389fffb55fSDavid Gibson TRACE(c, "%s", node->fullpath);
1396f05afcbSRob Herring if (c->fn)
1406f05afcbSRob Herring c->fn(c, dti, node);
1419fffb55fSDavid Gibson
1429fffb55fSDavid Gibson for_each_child(node, child)
1436f05afcbSRob Herring check_nodes_props(c, dti, child);
1449fffb55fSDavid Gibson }
1459fffb55fSDavid Gibson
is_multiple_of(int multiple,int divisor)146a77725a9SRob Herring static bool is_multiple_of(int multiple, int divisor)
147a77725a9SRob Herring {
148a77725a9SRob Herring if (divisor == 0)
149a77725a9SRob Herring return multiple == 0;
150a77725a9SRob Herring else
151a77725a9SRob Herring return (multiple % divisor) == 0;
152a77725a9SRob Herring }
153a77725a9SRob Herring
run_check(struct check * c,struct dt_info * dti)1546f05afcbSRob Herring static bool run_check(struct check *c, struct dt_info *dti)
1559fffb55fSDavid Gibson {
1566f05afcbSRob Herring struct node *dt = dti->dt;
15747605971SRob Herring bool error = false;
1589fffb55fSDavid Gibson int i;
1599fffb55fSDavid Gibson
1609fffb55fSDavid Gibson assert(!c->inprogress);
1619fffb55fSDavid Gibson
1629fffb55fSDavid Gibson if (c->status != UNCHECKED)
1639fffb55fSDavid Gibson goto out;
1649fffb55fSDavid Gibson
16547605971SRob Herring c->inprogress = true;
1669fffb55fSDavid Gibson
1679fffb55fSDavid Gibson for (i = 0; i < c->num_prereqs; i++) {
1689fffb55fSDavid Gibson struct check *prq = c->prereq[i];
1696f05afcbSRob Herring error = error || run_check(prq, dti);
1709fffb55fSDavid Gibson if (prq->status != PASSED) {
1719fffb55fSDavid Gibson c->status = PREREQ;
1729130ba88SRob Herring check_msg(c, dti, NULL, NULL, "Failed prerequisite '%s'",
1739fffb55fSDavid Gibson c->prereq[i]->name);
1749fffb55fSDavid Gibson }
1759fffb55fSDavid Gibson }
1769fffb55fSDavid Gibson
1779fffb55fSDavid Gibson if (c->status != UNCHECKED)
1789fffb55fSDavid Gibson goto out;
1799fffb55fSDavid Gibson
1806f05afcbSRob Herring check_nodes_props(c, dti, dt);
1819fffb55fSDavid Gibson
1829fffb55fSDavid Gibson if (c->status == UNCHECKED)
1839fffb55fSDavid Gibson c->status = PASSED;
1849fffb55fSDavid Gibson
1859fffb55fSDavid Gibson TRACE(c, "\tCompleted, status %d", c->status);
1869fffb55fSDavid Gibson
1879fffb55fSDavid Gibson out:
18847605971SRob Herring c->inprogress = false;
189cd296721SStephen Warren if ((c->status != PASSED) && (c->error))
19047605971SRob Herring error = true;
1919fffb55fSDavid Gibson return error;
1929fffb55fSDavid Gibson }
1939fffb55fSDavid Gibson
1949fffb55fSDavid Gibson /*
1959fffb55fSDavid Gibson * Utility check functions
1969fffb55fSDavid Gibson */
1979fffb55fSDavid Gibson
198cd296721SStephen Warren /* A check which always fails, for testing purposes only */
check_always_fail(struct check * c,struct dt_info * dti,struct node * node)1996f05afcbSRob Herring static inline void check_always_fail(struct check *c, struct dt_info *dti,
2006f05afcbSRob Herring struct node *node)
201cd296721SStephen Warren {
2029130ba88SRob Herring FAIL(c, dti, node, "always_fail check");
203cd296721SStephen Warren }
2046f05afcbSRob Herring CHECK(always_fail, check_always_fail, NULL);
205cd296721SStephen Warren
check_is_string(struct check * c,struct dt_info * dti,struct node * node)2066f05afcbSRob Herring static void check_is_string(struct check *c, struct dt_info *dti,
2079fffb55fSDavid Gibson struct node *node)
2089fffb55fSDavid Gibson {
2099fffb55fSDavid Gibson struct property *prop;
2109fffb55fSDavid Gibson char *propname = c->data;
2119fffb55fSDavid Gibson
2129fffb55fSDavid Gibson prop = get_property(node, propname);
2139fffb55fSDavid Gibson if (!prop)
2149fffb55fSDavid Gibson return; /* Not present, assumed ok */
2159fffb55fSDavid Gibson
2169fffb55fSDavid Gibson if (!data_is_one_string(prop->val))
2179130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "property is not a string");
2189fffb55fSDavid Gibson }
219cd296721SStephen Warren #define WARNING_IF_NOT_STRING(nm, propname) \
2206f05afcbSRob Herring WARNING(nm, check_is_string, (propname))
221cd296721SStephen Warren #define ERROR_IF_NOT_STRING(nm, propname) \
2226f05afcbSRob Herring ERROR(nm, check_is_string, (propname))
2239fffb55fSDavid Gibson
check_is_string_list(struct check * c,struct dt_info * dti,struct node * node)2249130ba88SRob Herring static void check_is_string_list(struct check *c, struct dt_info *dti,
2259130ba88SRob Herring struct node *node)
2269130ba88SRob Herring {
2279130ba88SRob Herring int rem, l;
2289130ba88SRob Herring struct property *prop;
2299130ba88SRob Herring char *propname = c->data;
2309130ba88SRob Herring char *str;
2319130ba88SRob Herring
2329130ba88SRob Herring prop = get_property(node, propname);
2339130ba88SRob Herring if (!prop)
2349130ba88SRob Herring return; /* Not present, assumed ok */
2359130ba88SRob Herring
2369130ba88SRob Herring str = prop->val.val;
2379130ba88SRob Herring rem = prop->val.len;
2389130ba88SRob Herring while (rem > 0) {
2399130ba88SRob Herring l = strnlen(str, rem);
2409130ba88SRob Herring if (l == rem) {
2419130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "property is not a string list");
2429130ba88SRob Herring break;
2439130ba88SRob Herring }
2449130ba88SRob Herring rem -= l + 1;
2459130ba88SRob Herring str += l + 1;
2469130ba88SRob Herring }
2479130ba88SRob Herring }
2489130ba88SRob Herring #define WARNING_IF_NOT_STRING_LIST(nm, propname) \
2499130ba88SRob Herring WARNING(nm, check_is_string_list, (propname))
2509130ba88SRob Herring #define ERROR_IF_NOT_STRING_LIST(nm, propname) \
2519130ba88SRob Herring ERROR(nm, check_is_string_list, (propname))
2529130ba88SRob Herring
check_is_cell(struct check * c,struct dt_info * dti,struct node * node)2536f05afcbSRob Herring static void check_is_cell(struct check *c, struct dt_info *dti,
2549fffb55fSDavid Gibson struct node *node)
2559fffb55fSDavid Gibson {
2569fffb55fSDavid Gibson struct property *prop;
2579fffb55fSDavid Gibson char *propname = c->data;
2589fffb55fSDavid Gibson
2599fffb55fSDavid Gibson prop = get_property(node, propname);
2609fffb55fSDavid Gibson if (!prop)
2619fffb55fSDavid Gibson return; /* Not present, assumed ok */
2629fffb55fSDavid Gibson
2639fffb55fSDavid Gibson if (prop->val.len != sizeof(cell_t))
2649130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "property is not a single cell");
2659fffb55fSDavid Gibson }
266cd296721SStephen Warren #define WARNING_IF_NOT_CELL(nm, propname) \
2676f05afcbSRob Herring WARNING(nm, check_is_cell, (propname))
268cd296721SStephen Warren #define ERROR_IF_NOT_CELL(nm, propname) \
2696f05afcbSRob Herring ERROR(nm, check_is_cell, (propname))
2709fffb55fSDavid Gibson
2719fffb55fSDavid Gibson /*
2729fffb55fSDavid Gibson * Structural check functions
2739fffb55fSDavid Gibson */
2749fffb55fSDavid Gibson
check_duplicate_node_names(struct check * c,struct dt_info * dti,struct node * node)2756f05afcbSRob Herring static void check_duplicate_node_names(struct check *c, struct dt_info *dti,
2769fffb55fSDavid Gibson struct node *node)
2779fffb55fSDavid Gibson {
2789fffb55fSDavid Gibson struct node *child, *child2;
2799fffb55fSDavid Gibson
2809fffb55fSDavid Gibson for_each_child(node, child)
2819fffb55fSDavid Gibson for (child2 = child->next_sibling;
2829fffb55fSDavid Gibson child2;
2839fffb55fSDavid Gibson child2 = child2->next_sibling)
2849fffb55fSDavid Gibson if (streq(child->name, child2->name))
28550aafd60SRob Herring FAIL(c, dti, child2, "Duplicate node name");
2869fffb55fSDavid Gibson }
2876f05afcbSRob Herring ERROR(duplicate_node_names, check_duplicate_node_names, NULL);
2889fffb55fSDavid Gibson
check_duplicate_property_names(struct check * c,struct dt_info * dti,struct node * node)2896f05afcbSRob Herring static void check_duplicate_property_names(struct check *c, struct dt_info *dti,
2909fffb55fSDavid Gibson struct node *node)
2919fffb55fSDavid Gibson {
2929fffb55fSDavid Gibson struct property *prop, *prop2;
2939fffb55fSDavid Gibson
294cd296721SStephen Warren for_each_property(node, prop) {
295cd296721SStephen Warren for (prop2 = prop->next; prop2; prop2 = prop2->next) {
296cd296721SStephen Warren if (prop2->deleted)
297cd296721SStephen Warren continue;
2989fffb55fSDavid Gibson if (streq(prop->name, prop2->name))
2999130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "Duplicate property name");
3009fffb55fSDavid Gibson }
301cd296721SStephen Warren }
302cd296721SStephen Warren }
3036f05afcbSRob Herring ERROR(duplicate_property_names, check_duplicate_property_names, NULL);
3049fffb55fSDavid Gibson
3059fffb55fSDavid Gibson #define LOWERCASE "abcdefghijklmnopqrstuvwxyz"
3069fffb55fSDavid Gibson #define UPPERCASE "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
3079fffb55fSDavid Gibson #define DIGITS "0123456789"
308a77725a9SRob Herring #define NODECHARS LOWERCASE UPPERCASE DIGITS ",._+-@"
309a77725a9SRob Herring #define PROPCHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-"
31089d12310SRob Herring #define PROPNODECHARSSTRICT LOWERCASE UPPERCASE DIGITS ",-"
3119fffb55fSDavid Gibson
check_node_name_chars(struct check * c,struct dt_info * dti,struct node * node)3126f05afcbSRob Herring static void check_node_name_chars(struct check *c, struct dt_info *dti,
3139fffb55fSDavid Gibson struct node *node)
3149fffb55fSDavid Gibson {
315a77725a9SRob Herring size_t n = strspn(node->name, c->data);
3169fffb55fSDavid Gibson
3179fffb55fSDavid Gibson if (n < strlen(node->name))
3189130ba88SRob Herring FAIL(c, dti, node, "Bad character '%c' in node name",
3199130ba88SRob Herring node->name[n]);
3209fffb55fSDavid Gibson }
321a77725a9SRob Herring ERROR(node_name_chars, check_node_name_chars, NODECHARS);
3229fffb55fSDavid Gibson
check_node_name_chars_strict(struct check * c,struct dt_info * dti,struct node * node)32389d12310SRob Herring static void check_node_name_chars_strict(struct check *c, struct dt_info *dti,
32489d12310SRob Herring struct node *node)
32589d12310SRob Herring {
32689d12310SRob Herring int n = strspn(node->name, c->data);
32789d12310SRob Herring
32889d12310SRob Herring if (n < node->basenamelen)
3299130ba88SRob Herring FAIL(c, dti, node, "Character '%c' not recommended in node name",
3309130ba88SRob Herring node->name[n]);
33189d12310SRob Herring }
33289d12310SRob Herring CHECK(node_name_chars_strict, check_node_name_chars_strict, PROPNODECHARSSTRICT);
33389d12310SRob Herring
check_node_name_format(struct check * c,struct dt_info * dti,struct node * node)3346f05afcbSRob Herring static void check_node_name_format(struct check *c, struct dt_info *dti,
3359fffb55fSDavid Gibson struct node *node)
3369fffb55fSDavid Gibson {
3379fffb55fSDavid Gibson if (strchr(get_unitname(node), '@'))
3389130ba88SRob Herring FAIL(c, dti, node, "multiple '@' characters in node name");
3399fffb55fSDavid Gibson }
3406f05afcbSRob Herring ERROR(node_name_format, check_node_name_format, NULL, &node_name_chars);
3419fffb55fSDavid Gibson
check_node_name_vs_property_name(struct check * c,struct dt_info * dti,struct node * node)342a77725a9SRob Herring static void check_node_name_vs_property_name(struct check *c,
343a77725a9SRob Herring struct dt_info *dti,
344a77725a9SRob Herring struct node *node)
345a77725a9SRob Herring {
346a77725a9SRob Herring if (!node->parent)
347a77725a9SRob Herring return;
348a77725a9SRob Herring
349a77725a9SRob Herring if (get_property(node->parent, node->name)) {
350a77725a9SRob Herring FAIL(c, dti, node, "node name and property name conflict");
351a77725a9SRob Herring }
352a77725a9SRob Herring }
353a77725a9SRob Herring WARNING(node_name_vs_property_name, check_node_name_vs_property_name,
354a77725a9SRob Herring NULL, &node_name_chars);
355a77725a9SRob Herring
check_unit_address_vs_reg(struct check * c,struct dt_info * dti,struct node * node)3566f05afcbSRob Herring static void check_unit_address_vs_reg(struct check *c, struct dt_info *dti,
357b9937347SRob Herring struct node *node)
358b9937347SRob Herring {
359b9937347SRob Herring const char *unitname = get_unitname(node);
360b9937347SRob Herring struct property *prop = get_property(node, "reg");
361b9937347SRob Herring
36250aafd60SRob Herring if (get_subnode(node, "__overlay__")) {
36350aafd60SRob Herring /* HACK: Overlay fragments are a special case */
36450aafd60SRob Herring return;
36550aafd60SRob Herring }
36650aafd60SRob Herring
367b9937347SRob Herring if (!prop) {
368b9937347SRob Herring prop = get_property(node, "ranges");
369b9937347SRob Herring if (prop && !prop->val.len)
370b9937347SRob Herring prop = NULL;
371b9937347SRob Herring }
372b9937347SRob Herring
373b9937347SRob Herring if (prop) {
374b9937347SRob Herring if (!unitname[0])
3759130ba88SRob Herring FAIL(c, dti, node, "node has a reg or ranges property, but no unit name");
376b9937347SRob Herring } else {
377b9937347SRob Herring if (unitname[0])
378d047cd8aSRob Herring FAIL(c, dti, node, "node has a unit name, but no reg or ranges property");
379b9937347SRob Herring }
380b9937347SRob Herring }
3816f05afcbSRob Herring WARNING(unit_address_vs_reg, check_unit_address_vs_reg, NULL);
382b9937347SRob Herring
check_property_name_chars(struct check * c,struct dt_info * dti,struct node * node)3836f05afcbSRob Herring static void check_property_name_chars(struct check *c, struct dt_info *dti,
3846f05afcbSRob Herring struct node *node)
3859fffb55fSDavid Gibson {
3866f05afcbSRob Herring struct property *prop;
3876f05afcbSRob Herring
3886f05afcbSRob Herring for_each_property(node, prop) {
389a77725a9SRob Herring size_t n = strspn(prop->name, c->data);
3909fffb55fSDavid Gibson
3919fffb55fSDavid Gibson if (n < strlen(prop->name))
3929130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name",
3939130ba88SRob Herring prop->name[n]);
3949fffb55fSDavid Gibson }
3956f05afcbSRob Herring }
396a77725a9SRob Herring ERROR(property_name_chars, check_property_name_chars, PROPCHARS);
3979fffb55fSDavid Gibson
check_property_name_chars_strict(struct check * c,struct dt_info * dti,struct node * node)39889d12310SRob Herring static void check_property_name_chars_strict(struct check *c,
39989d12310SRob Herring struct dt_info *dti,
40089d12310SRob Herring struct node *node)
40189d12310SRob Herring {
40289d12310SRob Herring struct property *prop;
40389d12310SRob Herring
40489d12310SRob Herring for_each_property(node, prop) {
40589d12310SRob Herring const char *name = prop->name;
406a77725a9SRob Herring size_t n = strspn(name, c->data);
40789d12310SRob Herring
40889d12310SRob Herring if (n == strlen(prop->name))
40989d12310SRob Herring continue;
41089d12310SRob Herring
41189d12310SRob Herring /* Certain names are whitelisted */
41289d12310SRob Herring if (streq(name, "device_type"))
41389d12310SRob Herring continue;
41489d12310SRob Herring
41589d12310SRob Herring /*
41689d12310SRob Herring * # is only allowed at the beginning of property names not counting
41789d12310SRob Herring * the vendor prefix.
41889d12310SRob Herring */
41989d12310SRob Herring if (name[n] == '#' && ((n == 0) || (name[n-1] == ','))) {
42089d12310SRob Herring name += n + 1;
42189d12310SRob Herring n = strspn(name, c->data);
42289d12310SRob Herring }
42389d12310SRob Herring if (n < strlen(name))
4249130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name",
4259130ba88SRob Herring name[n]);
42689d12310SRob Herring }
42789d12310SRob Herring }
42889d12310SRob Herring CHECK(property_name_chars_strict, check_property_name_chars_strict, PROPNODECHARSSTRICT);
42989d12310SRob Herring
430658f29a5SJohn Bonesio #define DESCLABEL_FMT "%s%s%s%s%s"
431658f29a5SJohn Bonesio #define DESCLABEL_ARGS(node,prop,mark) \
432658f29a5SJohn Bonesio ((mark) ? "value of " : ""), \
433658f29a5SJohn Bonesio ((prop) ? "'" : ""), \
434658f29a5SJohn Bonesio ((prop) ? (prop)->name : ""), \
435658f29a5SJohn Bonesio ((prop) ? "' in " : ""), (node)->fullpath
436658f29a5SJohn Bonesio
check_duplicate_label(struct check * c,struct dt_info * dti,const char * label,struct node * node,struct property * prop,struct marker * mark)4376f05afcbSRob Herring static void check_duplicate_label(struct check *c, struct dt_info *dti,
438658f29a5SJohn Bonesio const char *label, struct node *node,
439658f29a5SJohn Bonesio struct property *prop, struct marker *mark)
440658f29a5SJohn Bonesio {
4416f05afcbSRob Herring struct node *dt = dti->dt;
442658f29a5SJohn Bonesio struct node *othernode = NULL;
443658f29a5SJohn Bonesio struct property *otherprop = NULL;
444658f29a5SJohn Bonesio struct marker *othermark = NULL;
445658f29a5SJohn Bonesio
446658f29a5SJohn Bonesio othernode = get_node_by_label(dt, label);
447658f29a5SJohn Bonesio
448658f29a5SJohn Bonesio if (!othernode)
449658f29a5SJohn Bonesio otherprop = get_property_by_label(dt, label, &othernode);
450658f29a5SJohn Bonesio if (!othernode)
451658f29a5SJohn Bonesio othermark = get_marker_label(dt, label, &othernode,
452658f29a5SJohn Bonesio &otherprop);
453658f29a5SJohn Bonesio
454658f29a5SJohn Bonesio if (!othernode)
455658f29a5SJohn Bonesio return;
456658f29a5SJohn Bonesio
457658f29a5SJohn Bonesio if ((othernode != node) || (otherprop != prop) || (othermark != mark))
4589130ba88SRob Herring FAIL(c, dti, node, "Duplicate label '%s' on " DESCLABEL_FMT
459658f29a5SJohn Bonesio " and " DESCLABEL_FMT,
460658f29a5SJohn Bonesio label, DESCLABEL_ARGS(node, prop, mark),
461658f29a5SJohn Bonesio DESCLABEL_ARGS(othernode, otherprop, othermark));
462658f29a5SJohn Bonesio }
463658f29a5SJohn Bonesio
check_duplicate_label_node(struct check * c,struct dt_info * dti,struct node * node)4646f05afcbSRob Herring static void check_duplicate_label_node(struct check *c, struct dt_info *dti,
4659fffb55fSDavid Gibson struct node *node)
4669fffb55fSDavid Gibson {
467658f29a5SJohn Bonesio struct label *l;
4686f05afcbSRob Herring struct property *prop;
469658f29a5SJohn Bonesio
470658f29a5SJohn Bonesio for_each_label(node->labels, l)
4716f05afcbSRob Herring check_duplicate_label(c, dti, l->label, node, NULL, NULL);
4726f05afcbSRob Herring
4736f05afcbSRob Herring for_each_property(node, prop) {
474658f29a5SJohn Bonesio struct marker *m = prop->val.markers;
475658f29a5SJohn Bonesio
476658f29a5SJohn Bonesio for_each_label(prop->labels, l)
4776f05afcbSRob Herring check_duplicate_label(c, dti, l->label, node, prop, NULL);
478658f29a5SJohn Bonesio
479658f29a5SJohn Bonesio for_each_marker_of_type(m, LABEL)
4806f05afcbSRob Herring check_duplicate_label(c, dti, m->ref, node, prop, m);
481658f29a5SJohn Bonesio }
4826f05afcbSRob Herring }
4836f05afcbSRob Herring ERROR(duplicate_label, check_duplicate_label_node, NULL);
484658f29a5SJohn Bonesio
check_phandle_prop(struct check * c,struct dt_info * dti,struct node * node,const char * propname)4856f05afcbSRob Herring static cell_t check_phandle_prop(struct check *c, struct dt_info *dti,
4866f05afcbSRob Herring struct node *node, const char *propname)
487658f29a5SJohn Bonesio {
4886f05afcbSRob Herring struct node *root = dti->dt;
4896f05afcbSRob Herring struct property *prop;
490658f29a5SJohn Bonesio struct marker *m;
4919fffb55fSDavid Gibson cell_t phandle;
4929fffb55fSDavid Gibson
4936f05afcbSRob Herring prop = get_property(node, propname);
4946f05afcbSRob Herring if (!prop)
4956f05afcbSRob Herring return 0;
4969fffb55fSDavid Gibson
4979fffb55fSDavid Gibson if (prop->val.len != sizeof(cell_t)) {
4989130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property",
4999130ba88SRob Herring prop->val.len, prop->name);
5006f05afcbSRob Herring return 0;
501658f29a5SJohn Bonesio }
502658f29a5SJohn Bonesio
503658f29a5SJohn Bonesio m = prop->val.markers;
504658f29a5SJohn Bonesio for_each_marker_of_type(m, REF_PHANDLE) {
505658f29a5SJohn Bonesio assert(m->offset == 0);
506658f29a5SJohn Bonesio if (node != get_node_by_ref(root, m->ref))
507658f29a5SJohn Bonesio /* "Set this node's phandle equal to some
508658f29a5SJohn Bonesio * other node's phandle". That's nonsensical
509658f29a5SJohn Bonesio * by construction. */ {
5109130ba88SRob Herring FAIL(c, dti, node, "%s is a reference to another node",
5119130ba88SRob Herring prop->name);
512658f29a5SJohn Bonesio }
513658f29a5SJohn Bonesio /* But setting this node's phandle equal to its own
514658f29a5SJohn Bonesio * phandle is allowed - that means allocate a unique
515658f29a5SJohn Bonesio * phandle for this node, even if it's not otherwise
516658f29a5SJohn Bonesio * referenced. The value will be filled in later, so
5176f05afcbSRob Herring * we treat it as having no phandle data for now. */
5186f05afcbSRob Herring return 0;
5199fffb55fSDavid Gibson }
5209fffb55fSDavid Gibson
5219fffb55fSDavid Gibson phandle = propval_cell(prop);
522658f29a5SJohn Bonesio
523a77725a9SRob Herring if (!phandle_is_valid(phandle)) {
5249130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property",
5259130ba88SRob Herring phandle, prop->name);
5266f05afcbSRob Herring return 0;
5279fffb55fSDavid Gibson }
5289fffb55fSDavid Gibson
5296f05afcbSRob Herring return phandle;
5306f05afcbSRob Herring }
5316f05afcbSRob Herring
check_explicit_phandles(struct check * c,struct dt_info * dti,struct node * node)5326f05afcbSRob Herring static void check_explicit_phandles(struct check *c, struct dt_info *dti,
5336f05afcbSRob Herring struct node *node)
5346f05afcbSRob Herring {
5356f05afcbSRob Herring struct node *root = dti->dt;
5366f05afcbSRob Herring struct node *other;
5376f05afcbSRob Herring cell_t phandle, linux_phandle;
5386f05afcbSRob Herring
5396f05afcbSRob Herring /* Nothing should have assigned phandles yet */
5406f05afcbSRob Herring assert(!node->phandle);
5416f05afcbSRob Herring
5426f05afcbSRob Herring phandle = check_phandle_prop(c, dti, node, "phandle");
5436f05afcbSRob Herring
5446f05afcbSRob Herring linux_phandle = check_phandle_prop(c, dti, node, "linux,phandle");
5456f05afcbSRob Herring
5466f05afcbSRob Herring if (!phandle && !linux_phandle)
5476f05afcbSRob Herring /* No valid phandles; nothing further to check */
5486f05afcbSRob Herring return;
5496f05afcbSRob Herring
5506f05afcbSRob Herring if (linux_phandle && phandle && (phandle != linux_phandle))
5519130ba88SRob Herring FAIL(c, dti, node, "mismatching 'phandle' and 'linux,phandle'"
5529130ba88SRob Herring " properties");
5536f05afcbSRob Herring
5546f05afcbSRob Herring if (linux_phandle && !phandle)
5556f05afcbSRob Herring phandle = linux_phandle;
556658f29a5SJohn Bonesio
5579fffb55fSDavid Gibson other = get_node_by_phandle(root, phandle);
558658f29a5SJohn Bonesio if (other && (other != node)) {
5599130ba88SRob Herring FAIL(c, dti, node, "duplicated phandle 0x%x (seen before at %s)",
5609130ba88SRob Herring phandle, other->fullpath);
5619fffb55fSDavid Gibson return;
5629fffb55fSDavid Gibson }
5639fffb55fSDavid Gibson
5649fffb55fSDavid Gibson node->phandle = phandle;
5659fffb55fSDavid Gibson }
5666f05afcbSRob Herring ERROR(explicit_phandles, check_explicit_phandles, NULL);
5679fffb55fSDavid Gibson
check_name_properties(struct check * c,struct dt_info * dti,struct node * node)5686f05afcbSRob Herring static void check_name_properties(struct check *c, struct dt_info *dti,
5699fffb55fSDavid Gibson struct node *node)
5709fffb55fSDavid Gibson {
5719fffb55fSDavid Gibson struct property **pp, *prop = NULL;
5729fffb55fSDavid Gibson
5739fffb55fSDavid Gibson for (pp = &node->proplist; *pp; pp = &((*pp)->next))
5749fffb55fSDavid Gibson if (streq((*pp)->name, "name")) {
5759fffb55fSDavid Gibson prop = *pp;
5769fffb55fSDavid Gibson break;
5779fffb55fSDavid Gibson }
5789fffb55fSDavid Gibson
5799fffb55fSDavid Gibson if (!prop)
5809fffb55fSDavid Gibson return; /* No name property, that's fine */
5819fffb55fSDavid Gibson
582a77725a9SRob Herring if ((prop->val.len != node->basenamelen + 1U)
5839fffb55fSDavid Gibson || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
5849130ba88SRob Herring FAIL(c, dti, node, "\"name\" property is incorrect (\"%s\" instead"
5859130ba88SRob Herring " of base node name)", prop->val.val);
5869fffb55fSDavid Gibson } else {
5879fffb55fSDavid Gibson /* The name property is correct, and therefore redundant.
5889fffb55fSDavid Gibson * Delete it */
5899fffb55fSDavid Gibson *pp = prop->next;
5909fffb55fSDavid Gibson free(prop->name);
5919fffb55fSDavid Gibson data_free(prop->val);
5929fffb55fSDavid Gibson free(prop);
5939fffb55fSDavid Gibson }
5949fffb55fSDavid Gibson }
595cd296721SStephen Warren ERROR_IF_NOT_STRING(name_is_string, "name");
5966f05afcbSRob Herring ERROR(name_properties, check_name_properties, NULL, &name_is_string);
5979fffb55fSDavid Gibson
5989fffb55fSDavid Gibson /*
5999fffb55fSDavid Gibson * Reference fixup functions
6009fffb55fSDavid Gibson */
6019fffb55fSDavid Gibson
fixup_phandle_references(struct check * c,struct dt_info * dti,struct node * node)6026f05afcbSRob Herring static void fixup_phandle_references(struct check *c, struct dt_info *dti,
6036f05afcbSRob Herring struct node *node)
6049fffb55fSDavid Gibson {
6056f05afcbSRob Herring struct node *dt = dti->dt;
6066f05afcbSRob Herring struct property *prop;
6076f05afcbSRob Herring
6086f05afcbSRob Herring for_each_property(node, prop) {
6099fffb55fSDavid Gibson struct marker *m = prop->val.markers;
6109fffb55fSDavid Gibson struct node *refnode;
6119fffb55fSDavid Gibson cell_t phandle;
6129fffb55fSDavid Gibson
6139fffb55fSDavid Gibson for_each_marker_of_type(m, REF_PHANDLE) {
6149fffb55fSDavid Gibson assert(m->offset + sizeof(cell_t) <= prop->val.len);
6159fffb55fSDavid Gibson
6169fffb55fSDavid Gibson refnode = get_node_by_ref(dt, m->ref);
6179fffb55fSDavid Gibson if (! refnode) {
6186f05afcbSRob Herring if (!(dti->dtsflags & DTSF_PLUGIN))
6199130ba88SRob Herring FAIL(c, dti, node, "Reference to non-existent node or "
6206f05afcbSRob Herring "label \"%s\"\n", m->ref);
6216f05afcbSRob Herring else /* mark the entry as unresolved */
62289d12310SRob Herring *((fdt32_t *)(prop->val.val + m->offset)) =
6236f05afcbSRob Herring cpu_to_fdt32(0xffffffff);
6249fffb55fSDavid Gibson continue;
6259fffb55fSDavid Gibson }
6269fffb55fSDavid Gibson
6279fffb55fSDavid Gibson phandle = get_node_phandle(dt, refnode);
62889d12310SRob Herring *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
62950aafd60SRob Herring
63050aafd60SRob Herring reference_node(refnode);
6319fffb55fSDavid Gibson }
6329fffb55fSDavid Gibson }
6336f05afcbSRob Herring }
6346f05afcbSRob Herring ERROR(phandle_references, fixup_phandle_references, NULL,
6359fffb55fSDavid Gibson &duplicate_node_names, &explicit_phandles);
6369fffb55fSDavid Gibson
fixup_path_references(struct check * c,struct dt_info * dti,struct node * node)6376f05afcbSRob Herring static void fixup_path_references(struct check *c, struct dt_info *dti,
6386f05afcbSRob Herring struct node *node)
6399fffb55fSDavid Gibson {
6406f05afcbSRob Herring struct node *dt = dti->dt;
6416f05afcbSRob Herring struct property *prop;
6426f05afcbSRob Herring
6436f05afcbSRob Herring for_each_property(node, prop) {
6449fffb55fSDavid Gibson struct marker *m = prop->val.markers;
6459fffb55fSDavid Gibson struct node *refnode;
6469fffb55fSDavid Gibson char *path;
6479fffb55fSDavid Gibson
6489fffb55fSDavid Gibson for_each_marker_of_type(m, REF_PATH) {
6499fffb55fSDavid Gibson assert(m->offset <= prop->val.len);
6509fffb55fSDavid Gibson
6519fffb55fSDavid Gibson refnode = get_node_by_ref(dt, m->ref);
6529fffb55fSDavid Gibson if (!refnode) {
6539130ba88SRob Herring FAIL(c, dti, node, "Reference to non-existent node or label \"%s\"\n",
6549fffb55fSDavid Gibson m->ref);
6559fffb55fSDavid Gibson continue;
6569fffb55fSDavid Gibson }
6579fffb55fSDavid Gibson
6589fffb55fSDavid Gibson path = refnode->fullpath;
6599fffb55fSDavid Gibson prop->val = data_insert_at_marker(prop->val, m, path,
6609fffb55fSDavid Gibson strlen(path) + 1);
66150aafd60SRob Herring
66250aafd60SRob Herring reference_node(refnode);
6639fffb55fSDavid Gibson }
6649fffb55fSDavid Gibson }
6656f05afcbSRob Herring }
6666f05afcbSRob Herring ERROR(path_references, fixup_path_references, NULL, &duplicate_node_names);
6679fffb55fSDavid Gibson
fixup_omit_unused_nodes(struct check * c,struct dt_info * dti,struct node * node)66850aafd60SRob Herring static void fixup_omit_unused_nodes(struct check *c, struct dt_info *dti,
66950aafd60SRob Herring struct node *node)
67050aafd60SRob Herring {
6719bb9c6a1SRob Herring if (generate_symbols && node->labels)
6729bb9c6a1SRob Herring return;
67350aafd60SRob Herring if (node->omit_if_unused && !node->is_referenced)
67450aafd60SRob Herring delete_node(node);
67550aafd60SRob Herring }
67650aafd60SRob Herring ERROR(omit_unused_nodes, fixup_omit_unused_nodes, NULL, &phandle_references, &path_references);
67750aafd60SRob Herring
6789fffb55fSDavid Gibson /*
6799fffb55fSDavid Gibson * Semantic checks
6809fffb55fSDavid Gibson */
681cd296721SStephen Warren WARNING_IF_NOT_CELL(address_cells_is_cell, "#address-cells");
682cd296721SStephen Warren WARNING_IF_NOT_CELL(size_cells_is_cell, "#size-cells");
6839fffb55fSDavid Gibson
684cd296721SStephen Warren WARNING_IF_NOT_STRING(device_type_is_string, "device_type");
685cd296721SStephen Warren WARNING_IF_NOT_STRING(model_is_string, "model");
686cd296721SStephen Warren WARNING_IF_NOT_STRING(status_is_string, "status");
6879130ba88SRob Herring WARNING_IF_NOT_STRING(label_is_string, "label");
6889130ba88SRob Herring
6899130ba88SRob Herring WARNING_IF_NOT_STRING_LIST(compatible_is_string_list, "compatible");
6909130ba88SRob Herring
check_names_is_string_list(struct check * c,struct dt_info * dti,struct node * node)6919130ba88SRob Herring static void check_names_is_string_list(struct check *c, struct dt_info *dti,
6929130ba88SRob Herring struct node *node)
6939130ba88SRob Herring {
6949130ba88SRob Herring struct property *prop;
6959130ba88SRob Herring
6969130ba88SRob Herring for_each_property(node, prop) {
697a77725a9SRob Herring if (!strends(prop->name, "-names"))
6989130ba88SRob Herring continue;
6999130ba88SRob Herring
7009130ba88SRob Herring c->data = prop->name;
7019130ba88SRob Herring check_is_string_list(c, dti, node);
7029130ba88SRob Herring }
7039130ba88SRob Herring }
7049130ba88SRob Herring WARNING(names_is_string_list, check_names_is_string_list, NULL);
7059130ba88SRob Herring
check_alias_paths(struct check * c,struct dt_info * dti,struct node * node)7069130ba88SRob Herring static void check_alias_paths(struct check *c, struct dt_info *dti,
7079130ba88SRob Herring struct node *node)
7089130ba88SRob Herring {
7099130ba88SRob Herring struct property *prop;
7109130ba88SRob Herring
7119130ba88SRob Herring if (!streq(node->name, "aliases"))
7129130ba88SRob Herring return;
7139130ba88SRob Herring
7149130ba88SRob Herring for_each_property(node, prop) {
7150cec114eSRob Herring if (streq(prop->name, "phandle")
7160cec114eSRob Herring || streq(prop->name, "linux,phandle")) {
7170cec114eSRob Herring continue;
7180cec114eSRob Herring }
7190cec114eSRob Herring
7209130ba88SRob Herring if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) {
7219130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)",
7229130ba88SRob Herring prop->val.val);
7239130ba88SRob Herring continue;
7249130ba88SRob Herring }
7259130ba88SRob Herring if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name))
7269130ba88SRob Herring FAIL(c, dti, node, "aliases property name must include only lowercase and '-'");
7279130ba88SRob Herring }
7289130ba88SRob Herring }
7299130ba88SRob Herring WARNING(alias_paths, check_alias_paths, NULL);
7309fffb55fSDavid Gibson
fixup_addr_size_cells(struct check * c,struct dt_info * dti,struct node * node)7316f05afcbSRob Herring static void fixup_addr_size_cells(struct check *c, struct dt_info *dti,
7329fffb55fSDavid Gibson struct node *node)
7339fffb55fSDavid Gibson {
7349fffb55fSDavid Gibson struct property *prop;
7359fffb55fSDavid Gibson
7369fffb55fSDavid Gibson node->addr_cells = -1;
7379fffb55fSDavid Gibson node->size_cells = -1;
7389fffb55fSDavid Gibson
7399fffb55fSDavid Gibson prop = get_property(node, "#address-cells");
7409fffb55fSDavid Gibson if (prop)
7419fffb55fSDavid Gibson node->addr_cells = propval_cell(prop);
7429fffb55fSDavid Gibson
7439fffb55fSDavid Gibson prop = get_property(node, "#size-cells");
7449fffb55fSDavid Gibson if (prop)
7459fffb55fSDavid Gibson node->size_cells = propval_cell(prop);
7469fffb55fSDavid Gibson }
7476f05afcbSRob Herring WARNING(addr_size_cells, fixup_addr_size_cells, NULL,
7489fffb55fSDavid Gibson &address_cells_is_cell, &size_cells_is_cell);
7499fffb55fSDavid Gibson
7509fffb55fSDavid Gibson #define node_addr_cells(n) \
7519fffb55fSDavid Gibson (((n)->addr_cells == -1) ? 2 : (n)->addr_cells)
7529fffb55fSDavid Gibson #define node_size_cells(n) \
7539fffb55fSDavid Gibson (((n)->size_cells == -1) ? 1 : (n)->size_cells)
7549fffb55fSDavid Gibson
check_reg_format(struct check * c,struct dt_info * dti,struct node * node)7556f05afcbSRob Herring static void check_reg_format(struct check *c, struct dt_info *dti,
7569fffb55fSDavid Gibson struct node *node)
7579fffb55fSDavid Gibson {
7589fffb55fSDavid Gibson struct property *prop;
7599fffb55fSDavid Gibson int addr_cells, size_cells, entrylen;
7609fffb55fSDavid Gibson
7619fffb55fSDavid Gibson prop = get_property(node, "reg");
7629fffb55fSDavid Gibson if (!prop)
7639fffb55fSDavid Gibson return; /* No "reg", that's fine */
7649fffb55fSDavid Gibson
7659fffb55fSDavid Gibson if (!node->parent) {
7669130ba88SRob Herring FAIL(c, dti, node, "Root node has a \"reg\" property");
7679fffb55fSDavid Gibson return;
7689fffb55fSDavid Gibson }
7699fffb55fSDavid Gibson
7709fffb55fSDavid Gibson if (prop->val.len == 0)
7719130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "property is empty");
7729fffb55fSDavid Gibson
7739fffb55fSDavid Gibson addr_cells = node_addr_cells(node->parent);
7749fffb55fSDavid Gibson size_cells = node_size_cells(node->parent);
7759fffb55fSDavid Gibson entrylen = (addr_cells + size_cells) * sizeof(cell_t);
7769fffb55fSDavid Gibson
777a77725a9SRob Herring if (!is_multiple_of(prop->val.len, entrylen))
7789130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "property has invalid length (%d bytes) "
7799fffb55fSDavid Gibson "(#address-cells == %d, #size-cells == %d)",
7809130ba88SRob Herring prop->val.len, addr_cells, size_cells);
7819fffb55fSDavid Gibson }
7826f05afcbSRob Herring WARNING(reg_format, check_reg_format, NULL, &addr_size_cells);
7839fffb55fSDavid Gibson
check_ranges_format(struct check * c,struct dt_info * dti,struct node * node)7846f05afcbSRob Herring static void check_ranges_format(struct check *c, struct dt_info *dti,
7859fffb55fSDavid Gibson struct node *node)
7869fffb55fSDavid Gibson {
7879fffb55fSDavid Gibson struct property *prop;
7889fffb55fSDavid Gibson int c_addr_cells, p_addr_cells, c_size_cells, p_size_cells, entrylen;
789d047cd8aSRob Herring const char *ranges = c->data;
7909fffb55fSDavid Gibson
791d047cd8aSRob Herring prop = get_property(node, ranges);
7929fffb55fSDavid Gibson if (!prop)
7939fffb55fSDavid Gibson return;
7949fffb55fSDavid Gibson
7959fffb55fSDavid Gibson if (!node->parent) {
796d047cd8aSRob Herring FAIL_PROP(c, dti, node, prop, "Root node has a \"%s\" property",
797d047cd8aSRob Herring ranges);
7989fffb55fSDavid Gibson return;
7999fffb55fSDavid Gibson }
8009fffb55fSDavid Gibson
8019fffb55fSDavid Gibson p_addr_cells = node_addr_cells(node->parent);
8029fffb55fSDavid Gibson p_size_cells = node_size_cells(node->parent);
8039fffb55fSDavid Gibson c_addr_cells = node_addr_cells(node);
8049fffb55fSDavid Gibson c_size_cells = node_size_cells(node);
8059fffb55fSDavid Gibson entrylen = (p_addr_cells + c_addr_cells + c_size_cells) * sizeof(cell_t);
8069fffb55fSDavid Gibson
8079fffb55fSDavid Gibson if (prop->val.len == 0) {
8089fffb55fSDavid Gibson if (p_addr_cells != c_addr_cells)
809d047cd8aSRob Herring FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its "
8109fffb55fSDavid Gibson "#address-cells (%d) differs from %s (%d)",
811d047cd8aSRob Herring ranges, c_addr_cells, node->parent->fullpath,
8129fffb55fSDavid Gibson p_addr_cells);
8139fffb55fSDavid Gibson if (p_size_cells != c_size_cells)
814d047cd8aSRob Herring FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its "
8159fffb55fSDavid Gibson "#size-cells (%d) differs from %s (%d)",
816d047cd8aSRob Herring ranges, c_size_cells, node->parent->fullpath,
8179fffb55fSDavid Gibson p_size_cells);
818a77725a9SRob Herring } else if (!is_multiple_of(prop->val.len, entrylen)) {
819d047cd8aSRob Herring FAIL_PROP(c, dti, node, prop, "\"%s\" property has invalid length (%d bytes) "
8209fffb55fSDavid Gibson "(parent #address-cells == %d, child #address-cells == %d, "
821d047cd8aSRob Herring "#size-cells == %d)", ranges, prop->val.len,
8229fffb55fSDavid Gibson p_addr_cells, c_addr_cells, c_size_cells);
8239fffb55fSDavid Gibson }
8249fffb55fSDavid Gibson }
825d047cd8aSRob Herring WARNING(ranges_format, check_ranges_format, "ranges", &addr_size_cells);
826d047cd8aSRob Herring WARNING(dma_ranges_format, check_ranges_format, "dma-ranges", &addr_size_cells);
8279fffb55fSDavid Gibson
82889d12310SRob Herring static const struct bus_type pci_bus = {
82989d12310SRob Herring .name = "PCI",
83089d12310SRob Herring };
83189d12310SRob Herring
check_pci_bridge(struct check * c,struct dt_info * dti,struct node * node)83289d12310SRob Herring static void check_pci_bridge(struct check *c, struct dt_info *dti, struct node *node)
83389d12310SRob Herring {
83489d12310SRob Herring struct property *prop;
83589d12310SRob Herring cell_t *cells;
83689d12310SRob Herring
83789d12310SRob Herring prop = get_property(node, "device_type");
83889d12310SRob Herring if (!prop || !streq(prop->val.val, "pci"))
83989d12310SRob Herring return;
84089d12310SRob Herring
84189d12310SRob Herring node->bus = &pci_bus;
84289d12310SRob Herring
8439130ba88SRob Herring if (!strprefixeq(node->name, node->basenamelen, "pci") &&
8449130ba88SRob Herring !strprefixeq(node->name, node->basenamelen, "pcie"))
8459130ba88SRob Herring FAIL(c, dti, node, "node name is not \"pci\" or \"pcie\"");
84689d12310SRob Herring
84789d12310SRob Herring prop = get_property(node, "ranges");
84889d12310SRob Herring if (!prop)
8499130ba88SRob Herring FAIL(c, dti, node, "missing ranges for PCI bridge (or not a bridge)");
85089d12310SRob Herring
85189d12310SRob Herring if (node_addr_cells(node) != 3)
8529130ba88SRob Herring FAIL(c, dti, node, "incorrect #address-cells for PCI bridge");
85389d12310SRob Herring if (node_size_cells(node) != 2)
8549130ba88SRob Herring FAIL(c, dti, node, "incorrect #size-cells for PCI bridge");
85589d12310SRob Herring
85689d12310SRob Herring prop = get_property(node, "bus-range");
857970f04c8SRob Herring if (!prop)
85889d12310SRob Herring return;
859970f04c8SRob Herring
86089d12310SRob Herring if (prop->val.len != (sizeof(cell_t) * 2)) {
8619130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "value must be 2 cells");
86289d12310SRob Herring return;
86389d12310SRob Herring }
86489d12310SRob Herring cells = (cell_t *)prop->val.val;
86589d12310SRob Herring if (fdt32_to_cpu(cells[0]) > fdt32_to_cpu(cells[1]))
8669130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell");
86789d12310SRob Herring if (fdt32_to_cpu(cells[1]) > 0xff)
8689130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256");
86989d12310SRob Herring }
87089d12310SRob Herring WARNING(pci_bridge, check_pci_bridge, NULL,
87189d12310SRob Herring &device_type_is_string, &addr_size_cells);
87289d12310SRob Herring
check_pci_device_bus_num(struct check * c,struct dt_info * dti,struct node * node)87389d12310SRob Herring static void check_pci_device_bus_num(struct check *c, struct dt_info *dti, struct node *node)
87489d12310SRob Herring {
87589d12310SRob Herring struct property *prop;
87689d12310SRob Herring unsigned int bus_num, min_bus, max_bus;
87789d12310SRob Herring cell_t *cells;
87889d12310SRob Herring
87989d12310SRob Herring if (!node->parent || (node->parent->bus != &pci_bus))
88089d12310SRob Herring return;
88189d12310SRob Herring
88289d12310SRob Herring prop = get_property(node, "reg");
88389d12310SRob Herring if (!prop)
88489d12310SRob Herring return;
88589d12310SRob Herring
88689d12310SRob Herring cells = (cell_t *)prop->val.val;
88789d12310SRob Herring bus_num = (fdt32_to_cpu(cells[0]) & 0x00ff0000) >> 16;
88889d12310SRob Herring
88989d12310SRob Herring prop = get_property(node->parent, "bus-range");
89089d12310SRob Herring if (!prop) {
89189d12310SRob Herring min_bus = max_bus = 0;
89289d12310SRob Herring } else {
89389d12310SRob Herring cells = (cell_t *)prop->val.val;
89489d12310SRob Herring min_bus = fdt32_to_cpu(cells[0]);
895a77725a9SRob Herring max_bus = fdt32_to_cpu(cells[1]);
89689d12310SRob Herring }
89789d12310SRob Herring if ((bus_num < min_bus) || (bus_num > max_bus))
8989130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)",
8999130ba88SRob Herring bus_num, min_bus, max_bus);
90089d12310SRob Herring }
90189d12310SRob Herring WARNING(pci_device_bus_num, check_pci_device_bus_num, NULL, ®_format, &pci_bridge);
90289d12310SRob Herring
check_pci_device_reg(struct check * c,struct dt_info * dti,struct node * node)90389d12310SRob Herring static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct node *node)
90489d12310SRob Herring {
90589d12310SRob Herring struct property *prop;
90689d12310SRob Herring const char *unitname = get_unitname(node);
90789d12310SRob Herring char unit_addr[5];
90889d12310SRob Herring unsigned int dev, func, reg;
90989d12310SRob Herring cell_t *cells;
91089d12310SRob Herring
91189d12310SRob Herring if (!node->parent || (node->parent->bus != &pci_bus))
91289d12310SRob Herring return;
91389d12310SRob Herring
91489d12310SRob Herring prop = get_property(node, "reg");
9156e9c9686SRob Herring if (!prop)
91689d12310SRob Herring return;
91789d12310SRob Herring
91889d12310SRob Herring cells = (cell_t *)prop->val.val;
91989d12310SRob Herring if (cells[1] || cells[2])
9209130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0");
92189d12310SRob Herring
92289d12310SRob Herring reg = fdt32_to_cpu(cells[0]);
92389d12310SRob Herring dev = (reg & 0xf800) >> 11;
92489d12310SRob Herring func = (reg & 0x700) >> 8;
92589d12310SRob Herring
92689d12310SRob Herring if (reg & 0xff000000)
9279130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space");
92889d12310SRob Herring if (reg & 0x000000ff)
9299130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0");
93089d12310SRob Herring
93189d12310SRob Herring if (func == 0) {
93289d12310SRob Herring snprintf(unit_addr, sizeof(unit_addr), "%x", dev);
93389d12310SRob Herring if (streq(unitname, unit_addr))
93489d12310SRob Herring return;
93589d12310SRob Herring }
93689d12310SRob Herring
93789d12310SRob Herring snprintf(unit_addr, sizeof(unit_addr), "%x,%x", dev, func);
93889d12310SRob Herring if (streq(unitname, unit_addr))
93989d12310SRob Herring return;
94089d12310SRob Herring
9419130ba88SRob Herring FAIL(c, dti, node, "PCI unit address format error, expected \"%s\"",
9429130ba88SRob Herring unit_addr);
94389d12310SRob Herring }
94489d12310SRob Herring WARNING(pci_device_reg, check_pci_device_reg, NULL, ®_format, &pci_bridge);
94589d12310SRob Herring
94689d12310SRob Herring static const struct bus_type simple_bus = {
94789d12310SRob Herring .name = "simple-bus",
94889d12310SRob Herring };
94989d12310SRob Herring
node_is_compatible(struct node * node,const char * compat)95089d12310SRob Herring static bool node_is_compatible(struct node *node, const char *compat)
95189d12310SRob Herring {
95289d12310SRob Herring struct property *prop;
95389d12310SRob Herring const char *str, *end;
95489d12310SRob Herring
95589d12310SRob Herring prop = get_property(node, "compatible");
95689d12310SRob Herring if (!prop)
95789d12310SRob Herring return false;
95889d12310SRob Herring
95989d12310SRob Herring for (str = prop->val.val, end = str + prop->val.len; str < end;
96089d12310SRob Herring str += strnlen(str, end - str) + 1) {
961c2e7075cSRob Herring if (streq(str, compat))
96289d12310SRob Herring return true;
96389d12310SRob Herring }
96489d12310SRob Herring return false;
96589d12310SRob Herring }
96689d12310SRob Herring
check_simple_bus_bridge(struct check * c,struct dt_info * dti,struct node * node)96789d12310SRob Herring static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
96889d12310SRob Herring {
96989d12310SRob Herring if (node_is_compatible(node, "simple-bus"))
97089d12310SRob Herring node->bus = &simple_bus;
97189d12310SRob Herring }
972c2e7075cSRob Herring WARNING(simple_bus_bridge, check_simple_bus_bridge, NULL,
973c2e7075cSRob Herring &addr_size_cells, &compatible_is_string_list);
97489d12310SRob Herring
check_simple_bus_reg(struct check * c,struct dt_info * dti,struct node * node)97589d12310SRob Herring static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
97689d12310SRob Herring {
97789d12310SRob Herring struct property *prop;
97889d12310SRob Herring const char *unitname = get_unitname(node);
97989d12310SRob Herring char unit_addr[17];
98089d12310SRob Herring unsigned int size;
98189d12310SRob Herring uint64_t reg = 0;
98289d12310SRob Herring cell_t *cells = NULL;
98389d12310SRob Herring
98489d12310SRob Herring if (!node->parent || (node->parent->bus != &simple_bus))
98589d12310SRob Herring return;
98689d12310SRob Herring
98789d12310SRob Herring prop = get_property(node, "reg");
98889d12310SRob Herring if (prop)
98989d12310SRob Herring cells = (cell_t *)prop->val.val;
99089d12310SRob Herring else {
99189d12310SRob Herring prop = get_property(node, "ranges");
99289d12310SRob Herring if (prop && prop->val.len)
99389d12310SRob Herring /* skip of child address */
99489d12310SRob Herring cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
99589d12310SRob Herring }
99689d12310SRob Herring
99789d12310SRob Herring if (!cells) {
99889d12310SRob Herring if (node->parent->parent && !(node->bus == &simple_bus))
9999130ba88SRob Herring FAIL(c, dti, node, "missing or empty reg/ranges property");
100089d12310SRob Herring return;
100189d12310SRob Herring }
100289d12310SRob Herring
100389d12310SRob Herring size = node_addr_cells(node->parent);
100489d12310SRob Herring while (size--)
100589d12310SRob Herring reg = (reg << 32) | fdt32_to_cpu(*(cells++));
100689d12310SRob Herring
10074201d057SRob Herring snprintf(unit_addr, sizeof(unit_addr), "%"PRIx64, reg);
100889d12310SRob Herring if (!streq(unitname, unit_addr))
10099130ba88SRob Herring FAIL(c, dti, node, "simple-bus unit address format error, expected \"%s\"",
10109130ba88SRob Herring unit_addr);
101189d12310SRob Herring }
101289d12310SRob Herring WARNING(simple_bus_reg, check_simple_bus_reg, NULL, ®_format, &simple_bus_bridge);
101389d12310SRob Herring
1014f858927fSRob Herring static const struct bus_type i2c_bus = {
1015f858927fSRob Herring .name = "i2c-bus",
1016f858927fSRob Herring };
1017f858927fSRob Herring
check_i2c_bus_bridge(struct check * c,struct dt_info * dti,struct node * node)1018f858927fSRob Herring static void check_i2c_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
1019f858927fSRob Herring {
1020f858927fSRob Herring if (strprefixeq(node->name, node->basenamelen, "i2c-bus") ||
1021f858927fSRob Herring strprefixeq(node->name, node->basenamelen, "i2c-arb")) {
1022f858927fSRob Herring node->bus = &i2c_bus;
1023f858927fSRob Herring } else if (strprefixeq(node->name, node->basenamelen, "i2c")) {
1024f858927fSRob Herring struct node *child;
1025f858927fSRob Herring for_each_child(node, child) {
1026f858927fSRob Herring if (strprefixeq(child->name, node->basenamelen, "i2c-bus"))
1027f858927fSRob Herring return;
1028f858927fSRob Herring }
1029f858927fSRob Herring node->bus = &i2c_bus;
1030f858927fSRob Herring } else
1031f858927fSRob Herring return;
1032f858927fSRob Herring
1033f858927fSRob Herring if (!node->children)
1034f858927fSRob Herring return;
1035f858927fSRob Herring
1036f858927fSRob Herring if (node_addr_cells(node) != 1)
1037f858927fSRob Herring FAIL(c, dti, node, "incorrect #address-cells for I2C bus");
1038f858927fSRob Herring if (node_size_cells(node) != 0)
1039f858927fSRob Herring FAIL(c, dti, node, "incorrect #size-cells for I2C bus");
1040f858927fSRob Herring
1041f858927fSRob Herring }
1042f858927fSRob Herring WARNING(i2c_bus_bridge, check_i2c_bus_bridge, NULL, &addr_size_cells);
1043f858927fSRob Herring
10443eb619b2SRob Herring #define I2C_OWN_SLAVE_ADDRESS (1U << 30)
10453eb619b2SRob Herring #define I2C_TEN_BIT_ADDRESS (1U << 31)
10463eb619b2SRob Herring
check_i2c_bus_reg(struct check * c,struct dt_info * dti,struct node * node)1047f858927fSRob Herring static void check_i2c_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
1048f858927fSRob Herring {
1049f858927fSRob Herring struct property *prop;
1050f858927fSRob Herring const char *unitname = get_unitname(node);
1051f858927fSRob Herring char unit_addr[17];
1052f858927fSRob Herring uint32_t reg = 0;
1053f858927fSRob Herring int len;
1054f858927fSRob Herring cell_t *cells = NULL;
1055f858927fSRob Herring
1056f858927fSRob Herring if (!node->parent || (node->parent->bus != &i2c_bus))
1057f858927fSRob Herring return;
1058f858927fSRob Herring
1059f858927fSRob Herring prop = get_property(node, "reg");
1060f858927fSRob Herring if (prop)
1061f858927fSRob Herring cells = (cell_t *)prop->val.val;
1062f858927fSRob Herring
1063f858927fSRob Herring if (!cells) {
1064f858927fSRob Herring FAIL(c, dti, node, "missing or empty reg property");
1065f858927fSRob Herring return;
1066f858927fSRob Herring }
1067f858927fSRob Herring
1068f858927fSRob Herring reg = fdt32_to_cpu(*cells);
10693eb619b2SRob Herring /* Ignore I2C_OWN_SLAVE_ADDRESS */
10703eb619b2SRob Herring reg &= ~I2C_OWN_SLAVE_ADDRESS;
1071f858927fSRob Herring snprintf(unit_addr, sizeof(unit_addr), "%x", reg);
1072f858927fSRob Herring if (!streq(unitname, unit_addr))
1073f858927fSRob Herring FAIL(c, dti, node, "I2C bus unit address format error, expected \"%s\"",
1074f858927fSRob Herring unit_addr);
1075f858927fSRob Herring
1076f858927fSRob Herring for (len = prop->val.len; len > 0; len -= 4) {
1077f858927fSRob Herring reg = fdt32_to_cpu(*(cells++));
10783eb619b2SRob Herring /* Ignore I2C_OWN_SLAVE_ADDRESS */
10793eb619b2SRob Herring reg &= ~I2C_OWN_SLAVE_ADDRESS;
10803eb619b2SRob Herring
10813eb619b2SRob Herring if ((reg & I2C_TEN_BIT_ADDRESS) && ((reg & ~I2C_TEN_BIT_ADDRESS) > 0x3ff))
1082f858927fSRob Herring FAIL_PROP(c, dti, node, prop, "I2C address must be less than 10-bits, got \"0x%x\"",
1083f858927fSRob Herring reg);
10843eb619b2SRob Herring else if (reg > 0x7f)
10853eb619b2SRob Herring 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",
10863eb619b2SRob Herring reg);
1087f858927fSRob Herring }
1088f858927fSRob Herring }
1089f858927fSRob Herring WARNING(i2c_bus_reg, check_i2c_bus_reg, NULL, ®_format, &i2c_bus_bridge);
1090f858927fSRob Herring
1091f858927fSRob Herring static const struct bus_type spi_bus = {
1092f858927fSRob Herring .name = "spi-bus",
1093f858927fSRob Herring };
1094f858927fSRob Herring
check_spi_bus_bridge(struct check * c,struct dt_info * dti,struct node * node)1095f858927fSRob Herring static void check_spi_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
1096f858927fSRob Herring {
1097c2e7075cSRob Herring int spi_addr_cells = 1;
1098f858927fSRob Herring
1099f858927fSRob Herring if (strprefixeq(node->name, node->basenamelen, "spi")) {
1100f858927fSRob Herring node->bus = &spi_bus;
1101f858927fSRob Herring } else {
1102f858927fSRob Herring /* Try to detect SPI buses which don't have proper node name */
1103f858927fSRob Herring struct node *child;
1104f858927fSRob Herring
1105f858927fSRob Herring if (node_addr_cells(node) != 1 || node_size_cells(node) != 0)
1106f858927fSRob Herring return;
1107f858927fSRob Herring
1108f858927fSRob Herring for_each_child(node, child) {
1109f858927fSRob Herring struct property *prop;
1110f858927fSRob Herring for_each_property(child, prop) {
1111f858927fSRob Herring if (strprefixeq(prop->name, 4, "spi-")) {
1112f858927fSRob Herring node->bus = &spi_bus;
1113f858927fSRob Herring break;
1114f858927fSRob Herring }
1115f858927fSRob Herring }
1116f858927fSRob Herring if (node->bus == &spi_bus)
1117f858927fSRob Herring break;
1118f858927fSRob Herring }
1119f858927fSRob Herring
1120f858927fSRob Herring if (node->bus == &spi_bus && get_property(node, "reg"))
1121f858927fSRob Herring FAIL(c, dti, node, "node name for SPI buses should be 'spi'");
1122f858927fSRob Herring }
1123f858927fSRob Herring if (node->bus != &spi_bus || !node->children)
1124f858927fSRob Herring return;
1125f858927fSRob Herring
1126c2e7075cSRob Herring if (get_property(node, "spi-slave"))
1127c2e7075cSRob Herring spi_addr_cells = 0;
1128c2e7075cSRob Herring if (node_addr_cells(node) != spi_addr_cells)
1129f858927fSRob Herring FAIL(c, dti, node, "incorrect #address-cells for SPI bus");
1130f858927fSRob Herring if (node_size_cells(node) != 0)
1131f858927fSRob Herring FAIL(c, dti, node, "incorrect #size-cells for SPI bus");
1132f858927fSRob Herring
1133f858927fSRob Herring }
1134f858927fSRob Herring WARNING(spi_bus_bridge, check_spi_bus_bridge, NULL, &addr_size_cells);
1135f858927fSRob Herring
check_spi_bus_reg(struct check * c,struct dt_info * dti,struct node * node)1136f858927fSRob Herring static void check_spi_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
1137f858927fSRob Herring {
1138f858927fSRob Herring struct property *prop;
1139f858927fSRob Herring const char *unitname = get_unitname(node);
1140f858927fSRob Herring char unit_addr[9];
1141f858927fSRob Herring uint32_t reg = 0;
1142f858927fSRob Herring cell_t *cells = NULL;
1143f858927fSRob Herring
1144f858927fSRob Herring if (!node->parent || (node->parent->bus != &spi_bus))
1145f858927fSRob Herring return;
1146f858927fSRob Herring
1147c2e7075cSRob Herring if (get_property(node->parent, "spi-slave"))
1148c2e7075cSRob Herring return;
1149c2e7075cSRob Herring
1150f858927fSRob Herring prop = get_property(node, "reg");
1151f858927fSRob Herring if (prop)
1152f858927fSRob Herring cells = (cell_t *)prop->val.val;
1153f858927fSRob Herring
1154f858927fSRob Herring if (!cells) {
1155f858927fSRob Herring FAIL(c, dti, node, "missing or empty reg property");
1156f858927fSRob Herring return;
1157f858927fSRob Herring }
1158f858927fSRob Herring
1159f858927fSRob Herring reg = fdt32_to_cpu(*cells);
1160f858927fSRob Herring snprintf(unit_addr, sizeof(unit_addr), "%x", reg);
1161f858927fSRob Herring if (!streq(unitname, unit_addr))
1162f858927fSRob Herring FAIL(c, dti, node, "SPI bus unit address format error, expected \"%s\"",
1163f858927fSRob Herring unit_addr);
1164f858927fSRob Herring }
1165f858927fSRob Herring WARNING(spi_bus_reg, check_spi_bus_reg, NULL, ®_format, &spi_bus_bridge);
1166f858927fSRob Herring
check_unit_address_format(struct check * c,struct dt_info * dti,struct node * node)116789d12310SRob Herring static void check_unit_address_format(struct check *c, struct dt_info *dti,
116889d12310SRob Herring struct node *node)
116989d12310SRob Herring {
117089d12310SRob Herring const char *unitname = get_unitname(node);
117189d12310SRob Herring
117289d12310SRob Herring if (node->parent && node->parent->bus)
117389d12310SRob Herring return;
117489d12310SRob Herring
117589d12310SRob Herring if (!unitname[0])
117689d12310SRob Herring return;
117789d12310SRob Herring
117889d12310SRob Herring if (!strncmp(unitname, "0x", 2)) {
11799130ba88SRob Herring FAIL(c, dti, node, "unit name should not have leading \"0x\"");
118089d12310SRob Herring /* skip over 0x for next test */
118189d12310SRob Herring unitname += 2;
118289d12310SRob Herring }
118389d12310SRob Herring if (unitname[0] == '0' && isxdigit(unitname[1]))
11849130ba88SRob Herring FAIL(c, dti, node, "unit name should not have leading 0s");
118589d12310SRob Herring }
118689d12310SRob Herring WARNING(unit_address_format, check_unit_address_format, NULL,
118789d12310SRob Herring &node_name_format, &pci_bridge, &simple_bus_bridge);
118889d12310SRob Herring
11899fffb55fSDavid Gibson /*
11909fffb55fSDavid Gibson * Style checks
11919fffb55fSDavid Gibson */
check_avoid_default_addr_size(struct check * c,struct dt_info * dti,struct node * node)11926f05afcbSRob Herring static void check_avoid_default_addr_size(struct check *c, struct dt_info *dti,
11939fffb55fSDavid Gibson struct node *node)
11949fffb55fSDavid Gibson {
11959fffb55fSDavid Gibson struct property *reg, *ranges;
11969fffb55fSDavid Gibson
11979fffb55fSDavid Gibson if (!node->parent)
11989fffb55fSDavid Gibson return; /* Ignore root node */
11999fffb55fSDavid Gibson
12009fffb55fSDavid Gibson reg = get_property(node, "reg");
12019fffb55fSDavid Gibson ranges = get_property(node, "ranges");
12029fffb55fSDavid Gibson
12039fffb55fSDavid Gibson if (!reg && !ranges)
12049fffb55fSDavid Gibson return;
12059fffb55fSDavid Gibson
120647605971SRob Herring if (node->parent->addr_cells == -1)
12079130ba88SRob Herring FAIL(c, dti, node, "Relying on default #address-cells value");
12089fffb55fSDavid Gibson
120947605971SRob Herring if (node->parent->size_cells == -1)
12109130ba88SRob Herring FAIL(c, dti, node, "Relying on default #size-cells value");
12119fffb55fSDavid Gibson }
12126f05afcbSRob Herring WARNING(avoid_default_addr_size, check_avoid_default_addr_size, NULL,
12136f05afcbSRob Herring &addr_size_cells);
12149fffb55fSDavid Gibson
check_avoid_unnecessary_addr_size(struct check * c,struct dt_info * dti,struct node * node)12159130ba88SRob Herring static void check_avoid_unnecessary_addr_size(struct check *c, struct dt_info *dti,
12169130ba88SRob Herring struct node *node)
12179130ba88SRob Herring {
12189130ba88SRob Herring struct property *prop;
12199130ba88SRob Herring struct node *child;
12209130ba88SRob Herring bool has_reg = false;
12219130ba88SRob Herring
12229130ba88SRob Herring if (!node->parent || node->addr_cells < 0 || node->size_cells < 0)
12239130ba88SRob Herring return;
12249130ba88SRob Herring
12259130ba88SRob Herring if (get_property(node, "ranges") || !node->children)
12269130ba88SRob Herring return;
12279130ba88SRob Herring
12289130ba88SRob Herring for_each_child(node, child) {
12299130ba88SRob Herring prop = get_property(child, "reg");
12309130ba88SRob Herring if (prop)
12319130ba88SRob Herring has_reg = true;
12329130ba88SRob Herring }
12339130ba88SRob Herring
12349130ba88SRob Herring if (!has_reg)
12359130ba88SRob Herring FAIL(c, dti, node, "unnecessary #address-cells/#size-cells without \"ranges\" or child \"reg\" property");
12369130ba88SRob Herring }
12379130ba88SRob Herring WARNING(avoid_unnecessary_addr_size, check_avoid_unnecessary_addr_size, NULL, &avoid_default_addr_size);
12389130ba88SRob Herring
node_is_disabled(struct node * node)12399bb9c6a1SRob Herring static bool node_is_disabled(struct node *node)
12409bb9c6a1SRob Herring {
12419bb9c6a1SRob Herring struct property *prop;
12429bb9c6a1SRob Herring
12439bb9c6a1SRob Herring prop = get_property(node, "status");
12449bb9c6a1SRob Herring if (prop) {
12459bb9c6a1SRob Herring char *str = prop->val.val;
12469bb9c6a1SRob Herring if (streq("disabled", str))
12479bb9c6a1SRob Herring return true;
12489bb9c6a1SRob Herring }
12499bb9c6a1SRob Herring
12509bb9c6a1SRob Herring return false;
12519bb9c6a1SRob Herring }
12529bb9c6a1SRob Herring
check_unique_unit_address_common(struct check * c,struct dt_info * dti,struct node * node,bool disable_check)12539bb9c6a1SRob Herring static void check_unique_unit_address_common(struct check *c,
12549bb9c6a1SRob Herring struct dt_info *dti,
12559bb9c6a1SRob Herring struct node *node,
12569bb9c6a1SRob Herring bool disable_check)
125750aafd60SRob Herring {
125850aafd60SRob Herring struct node *childa;
125950aafd60SRob Herring
126050aafd60SRob Herring if (node->addr_cells < 0 || node->size_cells < 0)
126150aafd60SRob Herring return;
126250aafd60SRob Herring
126350aafd60SRob Herring if (!node->children)
126450aafd60SRob Herring return;
126550aafd60SRob Herring
126650aafd60SRob Herring for_each_child(node, childa) {
126750aafd60SRob Herring struct node *childb;
126850aafd60SRob Herring const char *addr_a = get_unitname(childa);
126950aafd60SRob Herring
127050aafd60SRob Herring if (!strlen(addr_a))
127150aafd60SRob Herring continue;
127250aafd60SRob Herring
12739bb9c6a1SRob Herring if (disable_check && node_is_disabled(childa))
12749bb9c6a1SRob Herring continue;
12759bb9c6a1SRob Herring
127650aafd60SRob Herring for_each_child(node, childb) {
127750aafd60SRob Herring const char *addr_b = get_unitname(childb);
127850aafd60SRob Herring if (childa == childb)
127950aafd60SRob Herring break;
128050aafd60SRob Herring
12819bb9c6a1SRob Herring if (disable_check && node_is_disabled(childb))
12829bb9c6a1SRob Herring continue;
12839bb9c6a1SRob Herring
128450aafd60SRob Herring if (streq(addr_a, addr_b))
128550aafd60SRob Herring FAIL(c, dti, childb, "duplicate unit-address (also used in node %s)", childa->fullpath);
128650aafd60SRob Herring }
128750aafd60SRob Herring }
128850aafd60SRob Herring }
12899bb9c6a1SRob Herring
check_unique_unit_address(struct check * c,struct dt_info * dti,struct node * node)12909bb9c6a1SRob Herring static void check_unique_unit_address(struct check *c, struct dt_info *dti,
12919bb9c6a1SRob Herring struct node *node)
12929bb9c6a1SRob Herring {
12939bb9c6a1SRob Herring check_unique_unit_address_common(c, dti, node, false);
12949bb9c6a1SRob Herring }
129550aafd60SRob Herring WARNING(unique_unit_address, check_unique_unit_address, NULL, &avoid_default_addr_size);
129650aafd60SRob Herring
check_unique_unit_address_if_enabled(struct check * c,struct dt_info * dti,struct node * node)12979bb9c6a1SRob Herring static void check_unique_unit_address_if_enabled(struct check *c, struct dt_info *dti,
12989bb9c6a1SRob Herring struct node *node)
12999bb9c6a1SRob Herring {
13009bb9c6a1SRob Herring check_unique_unit_address_common(c, dti, node, true);
13019bb9c6a1SRob Herring }
13029bb9c6a1SRob Herring CHECK_ENTRY(unique_unit_address_if_enabled, check_unique_unit_address_if_enabled,
13039bb9c6a1SRob Herring NULL, false, false, &avoid_default_addr_size);
13049bb9c6a1SRob Herring
check_obsolete_chosen_interrupt_controller(struct check * c,struct dt_info * dti,struct node * node)13059fffb55fSDavid Gibson static void check_obsolete_chosen_interrupt_controller(struct check *c,
13066f05afcbSRob Herring struct dt_info *dti,
13076f05afcbSRob Herring struct node *node)
13089fffb55fSDavid Gibson {
13096f05afcbSRob Herring struct node *dt = dti->dt;
13109fffb55fSDavid Gibson struct node *chosen;
13119fffb55fSDavid Gibson struct property *prop;
13129fffb55fSDavid Gibson
13136f05afcbSRob Herring if (node != dt)
13146f05afcbSRob Herring return;
13156f05afcbSRob Herring
13166f05afcbSRob Herring
13179fffb55fSDavid Gibson chosen = get_node_by_path(dt, "/chosen");
13189fffb55fSDavid Gibson if (!chosen)
13199fffb55fSDavid Gibson return;
13209fffb55fSDavid Gibson
13219fffb55fSDavid Gibson prop = get_property(chosen, "interrupt-controller");
13229fffb55fSDavid Gibson if (prop)
13239130ba88SRob Herring FAIL_PROP(c, dti, node, prop,
13249130ba88SRob Herring "/chosen has obsolete \"interrupt-controller\" property");
13259fffb55fSDavid Gibson }
13266f05afcbSRob Herring WARNING(obsolete_chosen_interrupt_controller,
13276f05afcbSRob Herring check_obsolete_chosen_interrupt_controller, NULL);
13289fffb55fSDavid Gibson
check_chosen_node_is_root(struct check * c,struct dt_info * dti,struct node * node)13299130ba88SRob Herring static void check_chosen_node_is_root(struct check *c, struct dt_info *dti,
13309130ba88SRob Herring struct node *node)
13319130ba88SRob Herring {
13329130ba88SRob Herring if (!streq(node->name, "chosen"))
13339130ba88SRob Herring return;
13349130ba88SRob Herring
13359130ba88SRob Herring if (node->parent != dti->dt)
13369130ba88SRob Herring FAIL(c, dti, node, "chosen node must be at root node");
13379130ba88SRob Herring }
13389130ba88SRob Herring WARNING(chosen_node_is_root, check_chosen_node_is_root, NULL);
13399130ba88SRob Herring
check_chosen_node_bootargs(struct check * c,struct dt_info * dti,struct node * node)13409130ba88SRob Herring static void check_chosen_node_bootargs(struct check *c, struct dt_info *dti,
13419130ba88SRob Herring struct node *node)
13429130ba88SRob Herring {
13439130ba88SRob Herring struct property *prop;
13449130ba88SRob Herring
13459130ba88SRob Herring if (!streq(node->name, "chosen"))
13469130ba88SRob Herring return;
13479130ba88SRob Herring
13489130ba88SRob Herring prop = get_property(node, "bootargs");
13499130ba88SRob Herring if (!prop)
13509130ba88SRob Herring return;
13519130ba88SRob Herring
13529130ba88SRob Herring c->data = prop->name;
13539130ba88SRob Herring check_is_string(c, dti, node);
13549130ba88SRob Herring }
13559130ba88SRob Herring WARNING(chosen_node_bootargs, check_chosen_node_bootargs, NULL);
13569130ba88SRob Herring
check_chosen_node_stdout_path(struct check * c,struct dt_info * dti,struct node * node)13579130ba88SRob Herring static void check_chosen_node_stdout_path(struct check *c, struct dt_info *dti,
13589130ba88SRob Herring struct node *node)
13599130ba88SRob Herring {
13609130ba88SRob Herring struct property *prop;
13619130ba88SRob Herring
13629130ba88SRob Herring if (!streq(node->name, "chosen"))
13639130ba88SRob Herring return;
13649130ba88SRob Herring
13659130ba88SRob Herring prop = get_property(node, "stdout-path");
13669130ba88SRob Herring if (!prop) {
13679130ba88SRob Herring prop = get_property(node, "linux,stdout-path");
13689130ba88SRob Herring if (!prop)
13699130ba88SRob Herring return;
13709130ba88SRob Herring FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead");
13719130ba88SRob Herring }
13729130ba88SRob Herring
13739130ba88SRob Herring c->data = prop->name;
13749130ba88SRob Herring check_is_string(c, dti, node);
13759130ba88SRob Herring }
13769130ba88SRob Herring WARNING(chosen_node_stdout_path, check_chosen_node_stdout_path, NULL);
13779130ba88SRob Herring
13784201d057SRob Herring struct provider {
13794201d057SRob Herring const char *prop_name;
13804201d057SRob Herring const char *cell_name;
13814201d057SRob Herring bool optional;
13824201d057SRob Herring };
13834201d057SRob Herring
check_property_phandle_args(struct check * c,struct dt_info * dti,struct node * node,struct property * prop,const struct provider * provider)13844201d057SRob Herring static void check_property_phandle_args(struct check *c,
13854201d057SRob Herring struct dt_info *dti,
13864201d057SRob Herring struct node *node,
13874201d057SRob Herring struct property *prop,
13884201d057SRob Herring const struct provider *provider)
13894201d057SRob Herring {
13904201d057SRob Herring struct node *root = dti->dt;
1391a77725a9SRob Herring unsigned int cell, cellsize = 0;
13924201d057SRob Herring
1393a77725a9SRob Herring if (!is_multiple_of(prop->val.len, sizeof(cell_t))) {
13949130ba88SRob Herring FAIL_PROP(c, dti, node, prop,
13959130ba88SRob Herring "property size (%d) is invalid, expected multiple of %zu",
13969130ba88SRob Herring prop->val.len, sizeof(cell_t));
13974201d057SRob Herring return;
13984201d057SRob Herring }
13994201d057SRob Herring
14004201d057SRob Herring for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {
14014201d057SRob Herring struct node *provider_node;
14024201d057SRob Herring struct property *cellprop;
1403a77725a9SRob Herring cell_t phandle;
1404*ea3723a5SRob Herring unsigned int expected;
14054201d057SRob Herring
14064201d057SRob Herring phandle = propval_cell_n(prop, cell);
14074201d057SRob Herring /*
14084201d057SRob Herring * Some bindings use a cell value 0 or -1 to skip over optional
14094201d057SRob Herring * entries when each index position has a specific definition.
14104201d057SRob Herring */
1411a77725a9SRob Herring if (!phandle_is_valid(phandle)) {
1412e45fe7f7SRob Herring /* Give up if this is an overlay with external references */
1413e45fe7f7SRob Herring if (dti->dtsflags & DTSF_PLUGIN)
1414e45fe7f7SRob Herring break;
1415e45fe7f7SRob Herring
14164201d057SRob Herring cellsize = 0;
14174201d057SRob Herring continue;
14184201d057SRob Herring }
14194201d057SRob Herring
14204201d057SRob Herring /* If we have markers, verify the current cell is a phandle */
14214201d057SRob Herring if (prop->val.markers) {
14224201d057SRob Herring struct marker *m = prop->val.markers;
14234201d057SRob Herring for_each_marker_of_type(m, REF_PHANDLE) {
14244201d057SRob Herring if (m->offset == (cell * sizeof(cell_t)))
14254201d057SRob Herring break;
14264201d057SRob Herring }
14274201d057SRob Herring if (!m)
14289130ba88SRob Herring FAIL_PROP(c, dti, node, prop,
14299130ba88SRob Herring "cell %d is not a phandle reference",
14309130ba88SRob Herring cell);
14314201d057SRob Herring }
14324201d057SRob Herring
14334201d057SRob Herring provider_node = get_node_by_phandle(root, phandle);
14344201d057SRob Herring if (!provider_node) {
14359130ba88SRob Herring FAIL_PROP(c, dti, node, prop,
14369130ba88SRob Herring "Could not get phandle node for (cell %d)",
14379130ba88SRob Herring cell);
14384201d057SRob Herring break;
14394201d057SRob Herring }
14404201d057SRob Herring
14414201d057SRob Herring cellprop = get_property(provider_node, provider->cell_name);
14424201d057SRob Herring if (cellprop) {
14434201d057SRob Herring cellsize = propval_cell(cellprop);
14444201d057SRob Herring } else if (provider->optional) {
14454201d057SRob Herring cellsize = 0;
14464201d057SRob Herring } else {
14479130ba88SRob Herring FAIL(c, dti, node, "Missing property '%s' in node %s or bad phandle (referred from %s[%d])",
14484201d057SRob Herring provider->cell_name,
14494201d057SRob Herring provider_node->fullpath,
14509130ba88SRob Herring prop->name, cell);
14514201d057SRob Herring break;
14524201d057SRob Herring }
14534201d057SRob Herring
1454*ea3723a5SRob Herring expected = (cell + cellsize + 1) * sizeof(cell_t);
1455*ea3723a5SRob Herring if ((expected <= cell) || prop->val.len < expected) {
14569130ba88SRob Herring FAIL_PROP(c, dti, node, prop,
1457*ea3723a5SRob Herring "property size (%d) too small for cell size %u",
14589130ba88SRob Herring prop->val.len, cellsize);
1459*ea3723a5SRob Herring break;
14604201d057SRob Herring }
14614201d057SRob Herring }
14624201d057SRob Herring }
14634201d057SRob Herring
check_provider_cells_property(struct check * c,struct dt_info * dti,struct node * node)14644201d057SRob Herring static void check_provider_cells_property(struct check *c,
14654201d057SRob Herring struct dt_info *dti,
14664201d057SRob Herring struct node *node)
14674201d057SRob Herring {
14684201d057SRob Herring struct provider *provider = c->data;
14694201d057SRob Herring struct property *prop;
14704201d057SRob Herring
14714201d057SRob Herring prop = get_property(node, provider->prop_name);
14724201d057SRob Herring if (!prop)
14734201d057SRob Herring return;
14744201d057SRob Herring
14754201d057SRob Herring check_property_phandle_args(c, dti, node, prop, provider);
14764201d057SRob Herring }
14774201d057SRob Herring #define WARNING_PROPERTY_PHANDLE_CELLS(nm, propname, cells_name, ...) \
14784201d057SRob Herring static struct provider nm##_provider = { (propname), (cells_name), __VA_ARGS__ }; \
1479a77725a9SRob Herring WARNING_IF_NOT_CELL(nm##_is_cell, cells_name); \
1480a77725a9SRob Herring WARNING(nm##_property, check_provider_cells_property, &nm##_provider, &nm##_is_cell, &phandle_references);
14814201d057SRob Herring
14824201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(clocks, "clocks", "#clock-cells");
14834201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(cooling_device, "cooling-device", "#cooling-cells");
14844201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(dmas, "dmas", "#dma-cells");
14854201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(hwlocks, "hwlocks", "#hwlock-cells");
14864201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(interrupts_extended, "interrupts-extended", "#interrupt-cells");
14874201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(io_channels, "io-channels", "#io-channel-cells");
14884201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(iommus, "iommus", "#iommu-cells");
14894201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(mboxes, "mboxes", "#mbox-cells");
14904201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(msi_parent, "msi-parent", "#msi-cells", true);
14914201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(mux_controls, "mux-controls", "#mux-control-cells");
14924201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(phys, "phys", "#phy-cells");
14934201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(power_domains, "power-domains", "#power-domain-cells");
14944201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(pwms, "pwms", "#pwm-cells");
14954201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(resets, "resets", "#reset-cells");
14969130ba88SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(sound_dai, "sound-dai", "#sound-dai-cells");
14974201d057SRob Herring WARNING_PROPERTY_PHANDLE_CELLS(thermal_sensors, "thermal-sensors", "#thermal-sensor-cells");
14984201d057SRob Herring
prop_is_gpio(struct property * prop)14994201d057SRob Herring static bool prop_is_gpio(struct property *prop)
15004201d057SRob Herring {
15014201d057SRob Herring /*
15024201d057SRob Herring * *-gpios and *-gpio can appear in property names,
15034201d057SRob Herring * so skip over any false matches (only one known ATM)
15044201d057SRob Herring */
1505a77725a9SRob Herring if (strends(prop->name, ",nr-gpios"))
15064201d057SRob Herring return false;
15074201d057SRob Herring
1508a77725a9SRob Herring return strends(prop->name, "-gpios") ||
1509a77725a9SRob Herring streq(prop->name, "gpios") ||
1510a77725a9SRob Herring strends(prop->name, "-gpio") ||
1511a77725a9SRob Herring streq(prop->name, "gpio");
15124201d057SRob Herring }
15134201d057SRob Herring
check_gpios_property(struct check * c,struct dt_info * dti,struct node * node)15144201d057SRob Herring static void check_gpios_property(struct check *c,
15154201d057SRob Herring struct dt_info *dti,
15164201d057SRob Herring struct node *node)
15174201d057SRob Herring {
15184201d057SRob Herring struct property *prop;
15194201d057SRob Herring
15204201d057SRob Herring /* Skip GPIO hog nodes which have 'gpios' property */
15214201d057SRob Herring if (get_property(node, "gpio-hog"))
15224201d057SRob Herring return;
15234201d057SRob Herring
15244201d057SRob Herring for_each_property(node, prop) {
15254201d057SRob Herring struct provider provider;
15264201d057SRob Herring
15274201d057SRob Herring if (!prop_is_gpio(prop))
15284201d057SRob Herring continue;
15294201d057SRob Herring
15304201d057SRob Herring provider.prop_name = prop->name;
15314201d057SRob Herring provider.cell_name = "#gpio-cells";
15324201d057SRob Herring provider.optional = false;
15334201d057SRob Herring check_property_phandle_args(c, dti, node, prop, &provider);
15344201d057SRob Herring }
15354201d057SRob Herring
15364201d057SRob Herring }
15374201d057SRob Herring WARNING(gpios_property, check_gpios_property, NULL, &phandle_references);
15384201d057SRob Herring
check_deprecated_gpio_property(struct check * c,struct dt_info * dti,struct node * node)15394201d057SRob Herring static void check_deprecated_gpio_property(struct check *c,
15404201d057SRob Herring struct dt_info *dti,
15414201d057SRob Herring struct node *node)
15424201d057SRob Herring {
15434201d057SRob Herring struct property *prop;
15444201d057SRob Herring
15454201d057SRob Herring for_each_property(node, prop) {
15464201d057SRob Herring if (!prop_is_gpio(prop))
15474201d057SRob Herring continue;
15484201d057SRob Herring
1549a77725a9SRob Herring if (!strends(prop->name, "gpio"))
15504201d057SRob Herring continue;
15514201d057SRob Herring
15529130ba88SRob Herring FAIL_PROP(c, dti, node, prop,
15539130ba88SRob Herring "'[*-]gpio' is deprecated, use '[*-]gpios' instead");
15544201d057SRob Herring }
15554201d057SRob Herring
15564201d057SRob Herring }
15574201d057SRob Herring CHECK(deprecated_gpio_property, check_deprecated_gpio_property, NULL);
15584201d057SRob Herring
node_is_interrupt_provider(struct node * node)15594201d057SRob Herring static bool node_is_interrupt_provider(struct node *node)
15604201d057SRob Herring {
15614201d057SRob Herring struct property *prop;
15624201d057SRob Herring
15634201d057SRob Herring prop = get_property(node, "interrupt-controller");
15644201d057SRob Herring if (prop)
15654201d057SRob Herring return true;
15664201d057SRob Herring
15674201d057SRob Herring prop = get_property(node, "interrupt-map");
15684201d057SRob Herring if (prop)
15694201d057SRob Herring return true;
15704201d057SRob Herring
15714201d057SRob Herring return false;
15724201d057SRob Herring }
15733eb619b2SRob Herring
check_interrupt_provider(struct check * c,struct dt_info * dti,struct node * node)15743eb619b2SRob Herring static void check_interrupt_provider(struct check *c,
15753eb619b2SRob Herring struct dt_info *dti,
15763eb619b2SRob Herring struct node *node)
15773eb619b2SRob Herring {
15783eb619b2SRob Herring struct property *prop;
1579a77725a9SRob Herring bool irq_provider = node_is_interrupt_provider(node);
15803eb619b2SRob Herring
15813eb619b2SRob Herring prop = get_property(node, "#interrupt-cells");
1582a77725a9SRob Herring if (irq_provider && !prop) {
15833eb619b2SRob Herring FAIL(c, dti, node,
1584a77725a9SRob Herring "Missing '#interrupt-cells' in interrupt provider");
1585a77725a9SRob Herring return;
15863eb619b2SRob Herring }
1587a77725a9SRob Herring
1588a77725a9SRob Herring if (!irq_provider && prop) {
1589a77725a9SRob Herring FAIL(c, dti, node,
1590a77725a9SRob Herring "'#interrupt-cells' found, but node is not an interrupt provider");
1591a77725a9SRob Herring return;
1592a77725a9SRob Herring }
1593a77725a9SRob Herring }
1594a77725a9SRob Herring WARNING(interrupt_provider, check_interrupt_provider, NULL, &interrupts_extended_is_cell);
1595a77725a9SRob Herring
check_interrupt_map(struct check * c,struct dt_info * dti,struct node * node)1596a77725a9SRob Herring static void check_interrupt_map(struct check *c,
1597a77725a9SRob Herring struct dt_info *dti,
1598a77725a9SRob Herring struct node *node)
1599a77725a9SRob Herring {
1600a77725a9SRob Herring struct node *root = dti->dt;
1601a77725a9SRob Herring struct property *prop, *irq_map_prop;
1602a77725a9SRob Herring size_t cellsize, cell, map_cells;
1603a77725a9SRob Herring
1604a77725a9SRob Herring irq_map_prop = get_property(node, "interrupt-map");
1605a77725a9SRob Herring if (!irq_map_prop)
1606a77725a9SRob Herring return;
1607a77725a9SRob Herring
1608a77725a9SRob Herring if (node->addr_cells < 0) {
1609a77725a9SRob Herring FAIL(c, dti, node,
1610a77725a9SRob Herring "Missing '#address-cells' in interrupt-map provider");
1611a77725a9SRob Herring return;
1612a77725a9SRob Herring }
1613a77725a9SRob Herring cellsize = node_addr_cells(node);
1614a77725a9SRob Herring cellsize += propval_cell(get_property(node, "#interrupt-cells"));
1615a77725a9SRob Herring
1616a77725a9SRob Herring prop = get_property(node, "interrupt-map-mask");
1617a77725a9SRob Herring if (prop && (prop->val.len != (cellsize * sizeof(cell_t))))
1618a77725a9SRob Herring FAIL_PROP(c, dti, node, prop,
1619a77725a9SRob Herring "property size (%d) is invalid, expected %zu",
1620a77725a9SRob Herring prop->val.len, cellsize * sizeof(cell_t));
1621a77725a9SRob Herring
1622a77725a9SRob Herring if (!is_multiple_of(irq_map_prop->val.len, sizeof(cell_t))) {
1623a77725a9SRob Herring FAIL_PROP(c, dti, node, irq_map_prop,
1624a77725a9SRob Herring "property size (%d) is invalid, expected multiple of %zu",
1625a77725a9SRob Herring irq_map_prop->val.len, sizeof(cell_t));
1626a77725a9SRob Herring return;
1627a77725a9SRob Herring }
1628a77725a9SRob Herring
1629a77725a9SRob Herring map_cells = irq_map_prop->val.len / sizeof(cell_t);
1630a77725a9SRob Herring for (cell = 0; cell < map_cells; ) {
1631a77725a9SRob Herring struct node *provider_node;
1632a77725a9SRob Herring struct property *cellprop;
1633a77725a9SRob Herring int phandle;
1634a77725a9SRob Herring size_t parent_cellsize;
1635a77725a9SRob Herring
1636a77725a9SRob Herring if ((cell + cellsize) >= map_cells) {
1637a77725a9SRob Herring FAIL_PROP(c, dti, node, irq_map_prop,
1638a77725a9SRob Herring "property size (%d) too small, expected > %zu",
1639a77725a9SRob Herring irq_map_prop->val.len, (cell + cellsize) * sizeof(cell_t));
1640a77725a9SRob Herring break;
1641a77725a9SRob Herring }
1642a77725a9SRob Herring cell += cellsize;
1643a77725a9SRob Herring
1644a77725a9SRob Herring phandle = propval_cell_n(irq_map_prop, cell);
1645a77725a9SRob Herring if (!phandle_is_valid(phandle)) {
1646a77725a9SRob Herring /* Give up if this is an overlay with external references */
1647a77725a9SRob Herring if (!(dti->dtsflags & DTSF_PLUGIN))
1648a77725a9SRob Herring FAIL_PROP(c, dti, node, irq_map_prop,
1649a77725a9SRob Herring "Cell %zu is not a phandle(%d)",
1650a77725a9SRob Herring cell, phandle);
1651a77725a9SRob Herring break;
1652a77725a9SRob Herring }
1653a77725a9SRob Herring
1654a77725a9SRob Herring provider_node = get_node_by_phandle(root, phandle);
1655a77725a9SRob Herring if (!provider_node) {
1656a77725a9SRob Herring FAIL_PROP(c, dti, node, irq_map_prop,
1657a77725a9SRob Herring "Could not get phandle(%d) node for (cell %zu)",
1658a77725a9SRob Herring phandle, cell);
1659a77725a9SRob Herring break;
1660a77725a9SRob Herring }
1661a77725a9SRob Herring
1662a77725a9SRob Herring cellprop = get_property(provider_node, "#interrupt-cells");
1663a77725a9SRob Herring if (cellprop) {
1664a77725a9SRob Herring parent_cellsize = propval_cell(cellprop);
1665a77725a9SRob Herring } else {
1666a77725a9SRob Herring FAIL(c, dti, node, "Missing property '#interrupt-cells' in node %s or bad phandle (referred from interrupt-map[%zu])",
1667a77725a9SRob Herring provider_node->fullpath, cell);
1668a77725a9SRob Herring break;
1669a77725a9SRob Herring }
1670a77725a9SRob Herring
1671a77725a9SRob Herring cellprop = get_property(provider_node, "#address-cells");
1672a77725a9SRob Herring if (cellprop)
1673a77725a9SRob Herring parent_cellsize += propval_cell(cellprop);
1674a77725a9SRob Herring
1675a77725a9SRob Herring cell += 1 + parent_cellsize;
1676a77725a9SRob Herring }
1677a77725a9SRob Herring }
1678a77725a9SRob Herring WARNING(interrupt_map, check_interrupt_map, NULL, &phandle_references, &addr_size_cells, &interrupt_provider);
16793eb619b2SRob Herring
check_interrupts_property(struct check * c,struct dt_info * dti,struct node * node)16804201d057SRob Herring static void check_interrupts_property(struct check *c,
16814201d057SRob Herring struct dt_info *dti,
16824201d057SRob Herring struct node *node)
16834201d057SRob Herring {
16844201d057SRob Herring struct node *root = dti->dt;
16854201d057SRob Herring struct node *irq_node = NULL, *parent = node;
16864201d057SRob Herring struct property *irq_prop, *prop = NULL;
1687a77725a9SRob Herring cell_t irq_cells, phandle;
16884201d057SRob Herring
16894201d057SRob Herring irq_prop = get_property(node, "interrupts");
16904201d057SRob Herring if (!irq_prop)
16914201d057SRob Herring return;
16924201d057SRob Herring
1693a77725a9SRob Herring if (!is_multiple_of(irq_prop->val.len, sizeof(cell_t)))
16949130ba88SRob Herring FAIL_PROP(c, dti, node, irq_prop, "size (%d) is invalid, expected multiple of %zu",
16959130ba88SRob Herring irq_prop->val.len, sizeof(cell_t));
16964201d057SRob Herring
16974201d057SRob Herring while (parent && !prop) {
16984201d057SRob Herring if (parent != node && node_is_interrupt_provider(parent)) {
16994201d057SRob Herring irq_node = parent;
17004201d057SRob Herring break;
17014201d057SRob Herring }
17024201d057SRob Herring
17034201d057SRob Herring prop = get_property(parent, "interrupt-parent");
17044201d057SRob Herring if (prop) {
17054201d057SRob Herring phandle = propval_cell(prop);
1706a77725a9SRob Herring if (!phandle_is_valid(phandle)) {
17079bb9c6a1SRob Herring /* Give up if this is an overlay with
17089bb9c6a1SRob Herring * external references */
17099bb9c6a1SRob Herring if (dti->dtsflags & DTSF_PLUGIN)
1710e45fe7f7SRob Herring return;
17119bb9c6a1SRob Herring FAIL_PROP(c, dti, parent, prop, "Invalid phandle");
17129bb9c6a1SRob Herring continue;
17139bb9c6a1SRob Herring }
1714e45fe7f7SRob Herring
17154201d057SRob Herring irq_node = get_node_by_phandle(root, phandle);
17164201d057SRob Herring if (!irq_node) {
17179130ba88SRob Herring FAIL_PROP(c, dti, parent, prop, "Bad phandle");
17184201d057SRob Herring return;
17194201d057SRob Herring }
17204201d057SRob Herring if (!node_is_interrupt_provider(irq_node))
17219130ba88SRob Herring FAIL(c, dti, irq_node,
17229130ba88SRob Herring "Missing interrupt-controller or interrupt-map property");
17234201d057SRob Herring
17244201d057SRob Herring break;
17254201d057SRob Herring }
17264201d057SRob Herring
17274201d057SRob Herring parent = parent->parent;
17284201d057SRob Herring }
17294201d057SRob Herring
17304201d057SRob Herring if (!irq_node) {
17319130ba88SRob Herring FAIL(c, dti, node, "Missing interrupt-parent");
17324201d057SRob Herring return;
17334201d057SRob Herring }
17344201d057SRob Herring
17354201d057SRob Herring prop = get_property(irq_node, "#interrupt-cells");
17364201d057SRob Herring if (!prop) {
17373eb619b2SRob Herring /* We warn about that already in another test. */
17384201d057SRob Herring return;
17394201d057SRob Herring }
17404201d057SRob Herring
17414201d057SRob Herring irq_cells = propval_cell(prop);
1742a77725a9SRob Herring if (!is_multiple_of(irq_prop->val.len, irq_cells * sizeof(cell_t))) {
17439130ba88SRob Herring FAIL_PROP(c, dti, node, prop,
17449130ba88SRob Herring "size is (%d), expected multiple of %d",
17459130ba88SRob Herring irq_prop->val.len, (int)(irq_cells * sizeof(cell_t)));
17464201d057SRob Herring }
17474201d057SRob Herring }
17484201d057SRob Herring WARNING(interrupts_property, check_interrupts_property, &phandle_references);
17494201d057SRob Herring
175050aafd60SRob Herring static const struct bus_type graph_port_bus = {
175150aafd60SRob Herring .name = "graph-port",
175250aafd60SRob Herring };
175350aafd60SRob Herring
175450aafd60SRob Herring static const struct bus_type graph_ports_bus = {
175550aafd60SRob Herring .name = "graph-ports",
175650aafd60SRob Herring };
175750aafd60SRob Herring
check_graph_nodes(struct check * c,struct dt_info * dti,struct node * node)175850aafd60SRob Herring static void check_graph_nodes(struct check *c, struct dt_info *dti,
175950aafd60SRob Herring struct node *node)
176050aafd60SRob Herring {
176150aafd60SRob Herring struct node *child;
176250aafd60SRob Herring
176350aafd60SRob Herring for_each_child(node, child) {
176450aafd60SRob Herring if (!(strprefixeq(child->name, child->basenamelen, "endpoint") ||
176550aafd60SRob Herring get_property(child, "remote-endpoint")))
176650aafd60SRob Herring continue;
176750aafd60SRob Herring
176850aafd60SRob Herring node->bus = &graph_port_bus;
176950aafd60SRob Herring
177050aafd60SRob Herring /* The parent of 'port' nodes can be either 'ports' or a device */
177150aafd60SRob Herring if (!node->parent->bus &&
177250aafd60SRob Herring (streq(node->parent->name, "ports") || get_property(node, "reg")))
177350aafd60SRob Herring node->parent->bus = &graph_ports_bus;
177450aafd60SRob Herring
177550aafd60SRob Herring break;
177650aafd60SRob Herring }
177750aafd60SRob Herring
177850aafd60SRob Herring }
177950aafd60SRob Herring WARNING(graph_nodes, check_graph_nodes, NULL);
178050aafd60SRob Herring
check_graph_child_address(struct check * c,struct dt_info * dti,struct node * node)178150aafd60SRob Herring static void check_graph_child_address(struct check *c, struct dt_info *dti,
178250aafd60SRob Herring struct node *node)
178350aafd60SRob Herring {
178450aafd60SRob Herring int cnt = 0;
178550aafd60SRob Herring struct node *child;
178650aafd60SRob Herring
178750aafd60SRob Herring if (node->bus != &graph_ports_bus && node->bus != &graph_port_bus)
178850aafd60SRob Herring return;
178950aafd60SRob Herring
179050aafd60SRob Herring for_each_child(node, child) {
179150aafd60SRob Herring struct property *prop = get_property(child, "reg");
179250aafd60SRob Herring
179350aafd60SRob Herring /* No error if we have any non-zero unit address */
179450aafd60SRob Herring if (prop && propval_cell(prop) != 0)
179550aafd60SRob Herring return;
179650aafd60SRob Herring
179750aafd60SRob Herring cnt++;
179850aafd60SRob Herring }
179950aafd60SRob Herring
180050aafd60SRob Herring if (cnt == 1 && node->addr_cells != -1)
180150aafd60SRob Herring FAIL(c, dti, node, "graph node has single child node '%s', #address-cells/#size-cells are not necessary",
180250aafd60SRob Herring node->children->name);
180350aafd60SRob Herring }
180450aafd60SRob Herring WARNING(graph_child_address, check_graph_child_address, NULL, &graph_nodes);
180550aafd60SRob Herring
check_graph_reg(struct check * c,struct dt_info * dti,struct node * node)180650aafd60SRob Herring static void check_graph_reg(struct check *c, struct dt_info *dti,
180750aafd60SRob Herring struct node *node)
180850aafd60SRob Herring {
180950aafd60SRob Herring char unit_addr[9];
181050aafd60SRob Herring const char *unitname = get_unitname(node);
181150aafd60SRob Herring struct property *prop;
181250aafd60SRob Herring
181350aafd60SRob Herring prop = get_property(node, "reg");
181450aafd60SRob Herring if (!prop || !unitname)
181550aafd60SRob Herring return;
181650aafd60SRob Herring
181750aafd60SRob Herring if (!(prop->val.val && prop->val.len == sizeof(cell_t))) {
181850aafd60SRob Herring FAIL(c, dti, node, "graph node malformed 'reg' property");
181950aafd60SRob Herring return;
182050aafd60SRob Herring }
182150aafd60SRob Herring
182250aafd60SRob Herring snprintf(unit_addr, sizeof(unit_addr), "%x", propval_cell(prop));
182350aafd60SRob Herring if (!streq(unitname, unit_addr))
182450aafd60SRob Herring FAIL(c, dti, node, "graph node unit address error, expected \"%s\"",
182550aafd60SRob Herring unit_addr);
182650aafd60SRob Herring
182750aafd60SRob Herring if (node->parent->addr_cells != 1)
182850aafd60SRob Herring FAIL_PROP(c, dti, node, get_property(node, "#address-cells"),
182950aafd60SRob Herring "graph node '#address-cells' is %d, must be 1",
183050aafd60SRob Herring node->parent->addr_cells);
183150aafd60SRob Herring if (node->parent->size_cells != 0)
183250aafd60SRob Herring FAIL_PROP(c, dti, node, get_property(node, "#size-cells"),
183350aafd60SRob Herring "graph node '#size-cells' is %d, must be 0",
183450aafd60SRob Herring node->parent->size_cells);
183550aafd60SRob Herring }
183650aafd60SRob Herring
check_graph_port(struct check * c,struct dt_info * dti,struct node * node)183750aafd60SRob Herring static void check_graph_port(struct check *c, struct dt_info *dti,
183850aafd60SRob Herring struct node *node)
183950aafd60SRob Herring {
184050aafd60SRob Herring if (node->bus != &graph_port_bus)
184150aafd60SRob Herring return;
184250aafd60SRob Herring
184350aafd60SRob Herring if (!strprefixeq(node->name, node->basenamelen, "port"))
184450aafd60SRob Herring FAIL(c, dti, node, "graph port node name should be 'port'");
184550aafd60SRob Herring
184650aafd60SRob Herring check_graph_reg(c, dti, node);
184750aafd60SRob Herring }
184850aafd60SRob Herring WARNING(graph_port, check_graph_port, NULL, &graph_nodes);
184950aafd60SRob Herring
get_remote_endpoint(struct check * c,struct dt_info * dti,struct node * endpoint)185050aafd60SRob Herring static struct node *get_remote_endpoint(struct check *c, struct dt_info *dti,
185150aafd60SRob Herring struct node *endpoint)
185250aafd60SRob Herring {
1853a77725a9SRob Herring cell_t phandle;
185450aafd60SRob Herring struct node *node;
185550aafd60SRob Herring struct property *prop;
185650aafd60SRob Herring
185750aafd60SRob Herring prop = get_property(endpoint, "remote-endpoint");
185850aafd60SRob Herring if (!prop)
185950aafd60SRob Herring return NULL;
186050aafd60SRob Herring
186150aafd60SRob Herring phandle = propval_cell(prop);
186250aafd60SRob Herring /* Give up if this is an overlay with external references */
1863a77725a9SRob Herring if (!phandle_is_valid(phandle))
186450aafd60SRob Herring return NULL;
186550aafd60SRob Herring
186650aafd60SRob Herring node = get_node_by_phandle(dti->dt, phandle);
186750aafd60SRob Herring if (!node)
186850aafd60SRob Herring FAIL_PROP(c, dti, endpoint, prop, "graph phandle is not valid");
186950aafd60SRob Herring
187050aafd60SRob Herring return node;
187150aafd60SRob Herring }
187250aafd60SRob Herring
check_graph_endpoint(struct check * c,struct dt_info * dti,struct node * node)187350aafd60SRob Herring static void check_graph_endpoint(struct check *c, struct dt_info *dti,
187450aafd60SRob Herring struct node *node)
187550aafd60SRob Herring {
187650aafd60SRob Herring struct node *remote_node;
187750aafd60SRob Herring
187850aafd60SRob Herring if (!node->parent || node->parent->bus != &graph_port_bus)
187950aafd60SRob Herring return;
188050aafd60SRob Herring
188150aafd60SRob Herring if (!strprefixeq(node->name, node->basenamelen, "endpoint"))
18829bb9c6a1SRob Herring FAIL(c, dti, node, "graph endpoint node name should be 'endpoint'");
188350aafd60SRob Herring
188450aafd60SRob Herring check_graph_reg(c, dti, node);
188550aafd60SRob Herring
188650aafd60SRob Herring remote_node = get_remote_endpoint(c, dti, node);
188750aafd60SRob Herring if (!remote_node)
188850aafd60SRob Herring return;
188950aafd60SRob Herring
189050aafd60SRob Herring if (get_remote_endpoint(c, dti, remote_node) != node)
189150aafd60SRob Herring FAIL(c, dti, node, "graph connection to node '%s' is not bidirectional",
189250aafd60SRob Herring remote_node->fullpath);
189350aafd60SRob Herring }
189450aafd60SRob Herring WARNING(graph_endpoint, check_graph_endpoint, NULL, &graph_nodes);
189550aafd60SRob Herring
18969fffb55fSDavid Gibson static struct check *check_table[] = {
18979fffb55fSDavid Gibson &duplicate_node_names, &duplicate_property_names,
18989fffb55fSDavid Gibson &node_name_chars, &node_name_format, &property_name_chars,
1899a77725a9SRob Herring &name_is_string, &name_properties, &node_name_vs_property_name,
1900658f29a5SJohn Bonesio
1901658f29a5SJohn Bonesio &duplicate_label,
1902658f29a5SJohn Bonesio
19039fffb55fSDavid Gibson &explicit_phandles,
19049fffb55fSDavid Gibson &phandle_references, &path_references,
190550aafd60SRob Herring &omit_unused_nodes,
19069fffb55fSDavid Gibson
1907a77725a9SRob Herring &address_cells_is_cell, &size_cells_is_cell,
19089fffb55fSDavid Gibson &device_type_is_string, &model_is_string, &status_is_string,
19099130ba88SRob Herring &label_is_string,
19109130ba88SRob Herring
19119130ba88SRob Herring &compatible_is_string_list, &names_is_string_list,
19129fffb55fSDavid Gibson
191389d12310SRob Herring &property_name_chars_strict,
191489d12310SRob Herring &node_name_chars_strict,
191589d12310SRob Herring
1916d047cd8aSRob Herring &addr_size_cells, ®_format, &ranges_format, &dma_ranges_format,
19179fffb55fSDavid Gibson
1918b9937347SRob Herring &unit_address_vs_reg,
191989d12310SRob Herring &unit_address_format,
192089d12310SRob Herring
192189d12310SRob Herring &pci_bridge,
192289d12310SRob Herring &pci_device_reg,
192389d12310SRob Herring &pci_device_bus_num,
192489d12310SRob Herring
192589d12310SRob Herring &simple_bus_bridge,
192689d12310SRob Herring &simple_bus_reg,
1927b9937347SRob Herring
1928f858927fSRob Herring &i2c_bus_bridge,
1929f858927fSRob Herring &i2c_bus_reg,
1930f858927fSRob Herring
1931f858927fSRob Herring &spi_bus_bridge,
1932f858927fSRob Herring &spi_bus_reg,
1933f858927fSRob Herring
19349fffb55fSDavid Gibson &avoid_default_addr_size,
19359130ba88SRob Herring &avoid_unnecessary_addr_size,
193650aafd60SRob Herring &unique_unit_address,
19379bb9c6a1SRob Herring &unique_unit_address_if_enabled,
19389fffb55fSDavid Gibson &obsolete_chosen_interrupt_controller,
19399130ba88SRob Herring &chosen_node_is_root, &chosen_node_bootargs, &chosen_node_stdout_path,
1940cd296721SStephen Warren
19414201d057SRob Herring &clocks_property,
1942a77725a9SRob Herring &clocks_is_cell,
19434201d057SRob Herring &cooling_device_property,
1944a77725a9SRob Herring &cooling_device_is_cell,
19454201d057SRob Herring &dmas_property,
1946a77725a9SRob Herring &dmas_is_cell,
19474201d057SRob Herring &hwlocks_property,
1948a77725a9SRob Herring &hwlocks_is_cell,
19494201d057SRob Herring &interrupts_extended_property,
1950a77725a9SRob Herring &interrupts_extended_is_cell,
19514201d057SRob Herring &io_channels_property,
1952a77725a9SRob Herring &io_channels_is_cell,
19534201d057SRob Herring &iommus_property,
1954a77725a9SRob Herring &iommus_is_cell,
19554201d057SRob Herring &mboxes_property,
1956a77725a9SRob Herring &mboxes_is_cell,
19574201d057SRob Herring &msi_parent_property,
1958a77725a9SRob Herring &msi_parent_is_cell,
19594201d057SRob Herring &mux_controls_property,
1960a77725a9SRob Herring &mux_controls_is_cell,
19614201d057SRob Herring &phys_property,
1962a77725a9SRob Herring &phys_is_cell,
19634201d057SRob Herring &power_domains_property,
1964a77725a9SRob Herring &power_domains_is_cell,
19654201d057SRob Herring &pwms_property,
1966a77725a9SRob Herring &pwms_is_cell,
19674201d057SRob Herring &resets_property,
1968a77725a9SRob Herring &resets_is_cell,
19699130ba88SRob Herring &sound_dai_property,
1970a77725a9SRob Herring &sound_dai_is_cell,
19714201d057SRob Herring &thermal_sensors_property,
1972a77725a9SRob Herring &thermal_sensors_is_cell,
19734201d057SRob Herring
19744201d057SRob Herring &deprecated_gpio_property,
19754201d057SRob Herring &gpios_property,
19764201d057SRob Herring &interrupts_property,
19773eb619b2SRob Herring &interrupt_provider,
1978a77725a9SRob Herring &interrupt_map,
19794201d057SRob Herring
19809130ba88SRob Herring &alias_paths,
19819130ba88SRob Herring
198250aafd60SRob Herring &graph_nodes, &graph_child_address, &graph_port, &graph_endpoint,
198350aafd60SRob Herring
1984cd296721SStephen Warren &always_fail,
19859fffb55fSDavid Gibson };
19869fffb55fSDavid Gibson
enable_warning_error(struct check * c,bool warn,bool error)1987cd296721SStephen Warren static void enable_warning_error(struct check *c, bool warn, bool error)
1988cd296721SStephen Warren {
1989cd296721SStephen Warren int i;
1990cd296721SStephen Warren
1991cd296721SStephen Warren /* Raising level, also raise it for prereqs */
1992cd296721SStephen Warren if ((warn && !c->warn) || (error && !c->error))
1993cd296721SStephen Warren for (i = 0; i < c->num_prereqs; i++)
1994cd296721SStephen Warren enable_warning_error(c->prereq[i], warn, error);
1995cd296721SStephen Warren
1996cd296721SStephen Warren c->warn = c->warn || warn;
1997cd296721SStephen Warren c->error = c->error || error;
1998cd296721SStephen Warren }
1999cd296721SStephen Warren
disable_warning_error(struct check * c,bool warn,bool error)2000cd296721SStephen Warren static void disable_warning_error(struct check *c, bool warn, bool error)
2001cd296721SStephen Warren {
2002a77725a9SRob Herring unsigned int i;
2003cd296721SStephen Warren
2004cd296721SStephen Warren /* Lowering level, also lower it for things this is the prereq
2005cd296721SStephen Warren * for */
2006cd296721SStephen Warren if ((warn && c->warn) || (error && c->error)) {
2007cd296721SStephen Warren for (i = 0; i < ARRAY_SIZE(check_table); i++) {
2008cd296721SStephen Warren struct check *cc = check_table[i];
2009cd296721SStephen Warren int j;
2010cd296721SStephen Warren
2011cd296721SStephen Warren for (j = 0; j < cc->num_prereqs; j++)
2012cd296721SStephen Warren if (cc->prereq[j] == c)
2013cd296721SStephen Warren disable_warning_error(cc, warn, error);
2014cd296721SStephen Warren }
2015cd296721SStephen Warren }
2016cd296721SStephen Warren
2017cd296721SStephen Warren c->warn = c->warn && !warn;
2018cd296721SStephen Warren c->error = c->error && !error;
2019cd296721SStephen Warren }
2020cd296721SStephen Warren
parse_checks_option(bool warn,bool error,const char * arg)202147605971SRob Herring void parse_checks_option(bool warn, bool error, const char *arg)
2022cd296721SStephen Warren {
2023a77725a9SRob Herring unsigned int i;
202447605971SRob Herring const char *name = arg;
2025cd296721SStephen Warren bool enable = true;
2026cd296721SStephen Warren
202747605971SRob Herring if ((strncmp(arg, "no-", 3) == 0)
202847605971SRob Herring || (strncmp(arg, "no_", 3) == 0)) {
202947605971SRob Herring name = arg + 3;
2030cd296721SStephen Warren enable = false;
2031cd296721SStephen Warren }
2032cd296721SStephen Warren
2033cd296721SStephen Warren for (i = 0; i < ARRAY_SIZE(check_table); i++) {
2034cd296721SStephen Warren struct check *c = check_table[i];
2035cd296721SStephen Warren
2036cd296721SStephen Warren if (streq(c->name, name)) {
2037cd296721SStephen Warren if (enable)
2038cd296721SStephen Warren enable_warning_error(c, warn, error);
2039cd296721SStephen Warren else
2040cd296721SStephen Warren disable_warning_error(c, warn, error);
2041cd296721SStephen Warren return;
2042cd296721SStephen Warren }
2043cd296721SStephen Warren }
2044cd296721SStephen Warren
2045cd296721SStephen Warren die("Unrecognized check name \"%s\"\n", name);
2046cd296721SStephen Warren }
2047cd296721SStephen Warren
process_checks(bool force,struct dt_info * dti)20486f05afcbSRob Herring void process_checks(bool force, struct dt_info *dti)
20499fffb55fSDavid Gibson {
2050a77725a9SRob Herring unsigned int i;
20519fffb55fSDavid Gibson int error = 0;
20529fffb55fSDavid Gibson
20539fffb55fSDavid Gibson for (i = 0; i < ARRAY_SIZE(check_table); i++) {
20549fffb55fSDavid Gibson struct check *c = check_table[i];
20559fffb55fSDavid Gibson
2056cd296721SStephen Warren if (c->warn || c->error)
20576f05afcbSRob Herring error = error || run_check(c, dti);
20589fffb55fSDavid Gibson }
20599fffb55fSDavid Gibson
20609fffb55fSDavid Gibson if (error) {
20619fffb55fSDavid Gibson if (!force) {
20629fffb55fSDavid Gibson fprintf(stderr, "ERROR: Input tree has errors, aborting "
20639fffb55fSDavid Gibson "(use -f to force output)\n");
20649fffb55fSDavid Gibson exit(2);
20659fffb55fSDavid Gibson } else if (quiet < 3) {
20669fffb55fSDavid Gibson fprintf(stderr, "Warning: Input tree has errors, "
20679fffb55fSDavid Gibson "output forced\n");
20689fffb55fSDavid Gibson }
20699fffb55fSDavid Gibson }
20709fffb55fSDavid Gibson }
2071