1 /* $NetBSD: checks.c,v 1.1.1.3 2019/12/22 12:34:02 skrll Exp $ */
2
3 // SPDX-License-Identifier: GPL-2.0-or-later
4 /*
5 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2007.
6 */
7
8 #include "dtc.h"
9 #include "srcpos.h"
10
11 #ifdef TRACE_CHECKS
12 #define TRACE(c, ...) \
13 do { \
14 fprintf(stderr, "=== %s: ", (c)->name); \
15 fprintf(stderr, __VA_ARGS__); \
16 fprintf(stderr, "\n"); \
17 } while (0)
18 #else
19 #define TRACE(c, fmt, ...) do { } while (0)
20 #endif
21
22 enum checkstatus {
23 UNCHECKED = 0,
24 PREREQ,
25 PASSED,
26 FAILED,
27 };
28
29 struct check;
30
31 typedef void (*check_fn)(struct check *c, struct dt_info *dti, struct node *node);
32
33 struct check {
34 const char *name;
35 check_fn fn;
36 void *data;
37 bool warn, error;
38 enum checkstatus status;
39 bool inprogress;
40 int num_prereqs;
41 struct check **prereq;
42 };
43
44 #define CHECK_ENTRY(nm_, fn_, d_, w_, e_, ...) \
45 static struct check *nm_##_prereqs[] = { __VA_ARGS__ }; \
46 static struct check nm_ = { \
47 .name = #nm_, \
48 .fn = (fn_), \
49 .data = (d_), \
50 .warn = (w_), \
51 .error = (e_), \
52 .status = UNCHECKED, \
53 .num_prereqs = ARRAY_SIZE(nm_##_prereqs), \
54 .prereq = nm_##_prereqs, \
55 };
56 #define WARNING(nm_, fn_, d_, ...) \
57 CHECK_ENTRY(nm_, fn_, d_, true, false, __VA_ARGS__)
58 #define ERROR(nm_, fn_, d_, ...) \
59 CHECK_ENTRY(nm_, fn_, d_, false, true, __VA_ARGS__)
60 #define CHECK(nm_, fn_, d_, ...) \
61 CHECK_ENTRY(nm_, fn_, d_, false, false, __VA_ARGS__)
62
check_msg(struct check * c,struct dt_info * dti,struct node * node,struct property * prop,const char * fmt,...)63 static inline void PRINTF(5, 6) check_msg(struct check *c, struct dt_info *dti,
64 struct node *node,
65 struct property *prop,
66 const char *fmt, ...)
67 {
68 va_list ap;
69 char *str = NULL;
70 struct srcpos *pos = NULL;
71 char *file_str;
72
73 if (!(c->warn && (quiet < 1)) && !(c->error && (quiet < 2)))
74 return;
75
76 if (prop && prop->srcpos)
77 pos = prop->srcpos;
78 else if (node && node->srcpos)
79 pos = node->srcpos;
80
81 if (pos) {
82 file_str = srcpos_string(pos);
83 xasprintf(&str, "%s", file_str);
84 free(file_str);
85 } else if (streq(dti->outname, "-")) {
86 xasprintf(&str, "<stdout>");
87 } else {
88 xasprintf(&str, "%s", dti->outname);
89 }
90
91 xasprintf_append(&str, ": %s (%s): ",
92 (c->error) ? "ERROR" : "Warning", c->name);
93
94 if (node) {
95 if (prop)
96 xasprintf_append(&str, "%s:%s: ", node->fullpath, prop->name);
97 else
98 xasprintf_append(&str, "%s: ", node->fullpath);
99 }
100
101 va_start(ap, fmt);
102 xavsprintf_append(&str, fmt, ap);
103 va_end(ap);
104
105 xasprintf_append(&str, "\n");
106
107 if (!prop && pos) {
108 pos = node->srcpos;
109 while (pos->next) {
110 pos = pos->next;
111
112 file_str = srcpos_string(pos);
113 xasprintf_append(&str, " also defined at %s\n", file_str);
114 free(file_str);
115 }
116 }
117
118 fputs(str, stderr);
119 }
120
121 #define FAIL(c, dti, node, ...) \
122 do { \
123 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
124 (c)->status = FAILED; \
125 check_msg((c), dti, node, NULL, __VA_ARGS__); \
126 } while (0)
127
128 #define FAIL_PROP(c, dti, node, prop, ...) \
129 do { \
130 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
131 (c)->status = FAILED; \
132 check_msg((c), dti, node, prop, __VA_ARGS__); \
133 } while (0)
134
135
check_nodes_props(struct check * c,struct dt_info * dti,struct node * node)136 static void check_nodes_props(struct check *c, struct dt_info *dti, struct node *node)
137 {
138 struct node *child;
139
140 TRACE(c, "%s", node->fullpath);
141 if (c->fn)
142 c->fn(c, dti, node);
143
144 for_each_child(node, child)
145 check_nodes_props(c, dti, child);
146 }
147
run_check(struct check * c,struct dt_info * dti)148 static bool run_check(struct check *c, struct dt_info *dti)
149 {
150 struct node *dt = dti->dt;
151 bool error = false;
152 int i;
153
154 assert(!c->inprogress);
155
156 if (c->status != UNCHECKED)
157 goto out;
158
159 c->inprogress = true;
160
161 for (i = 0; i < c->num_prereqs; i++) {
162 struct check *prq = c->prereq[i];
163 error = error || run_check(prq, dti);
164 if (prq->status != PASSED) {
165 c->status = PREREQ;
166 check_msg(c, dti, NULL, NULL, "Failed prerequisite '%s'",
167 c->prereq[i]->name);
168 }
169 }
170
171 if (c->status != UNCHECKED)
172 goto out;
173
174 check_nodes_props(c, dti, dt);
175
176 if (c->status == UNCHECKED)
177 c->status = PASSED;
178
179 TRACE(c, "\tCompleted, status %d", c->status);
180
181 out:
182 c->inprogress = false;
183 if ((c->status != PASSED) && (c->error))
184 error = true;
185 return error;
186 }
187
188 /*
189 * Utility check functions
190 */
191
192 /* A check which always fails, for testing purposes only */
check_always_fail(struct check * c,struct dt_info * dti,struct node * node)193 static inline void check_always_fail(struct check *c, struct dt_info *dti,
194 struct node *node)
195 {
196 FAIL(c, dti, node, "always_fail check");
197 }
198 CHECK(always_fail, check_always_fail, NULL);
199
check_is_string(struct check * c,struct dt_info * dti,struct node * node)200 static void check_is_string(struct check *c, struct dt_info *dti,
201 struct node *node)
202 {
203 struct property *prop;
204 char *propname = c->data;
205
206 prop = get_property(node, propname);
207 if (!prop)
208 return; /* Not present, assumed ok */
209
210 if (!data_is_one_string(prop->val))
211 FAIL_PROP(c, dti, node, prop, "property is not a string");
212 }
213 #define WARNING_IF_NOT_STRING(nm, propname) \
214 WARNING(nm, check_is_string, (propname))
215 #define ERROR_IF_NOT_STRING(nm, propname) \
216 ERROR(nm, check_is_string, (propname))
217
check_is_string_list(struct check * c,struct dt_info * dti,struct node * node)218 static void check_is_string_list(struct check *c, struct dt_info *dti,
219 struct node *node)
220 {
221 int rem, l;
222 struct property *prop;
223 char *propname = c->data;
224 char *str;
225
226 prop = get_property(node, propname);
227 if (!prop)
228 return; /* Not present, assumed ok */
229
230 str = prop->val.val;
231 rem = prop->val.len;
232 while (rem > 0) {
233 l = strnlen(str, rem);
234 if (l == rem) {
235 FAIL_PROP(c, dti, node, prop, "property is not a string list");
236 break;
237 }
238 rem -= l + 1;
239 str += l + 1;
240 }
241 }
242 #define WARNING_IF_NOT_STRING_LIST(nm, propname) \
243 WARNING(nm, check_is_string_list, (propname))
244 #define ERROR_IF_NOT_STRING_LIST(nm, propname) \
245 ERROR(nm, check_is_string_list, (propname))
246
check_is_cell(struct check * c,struct dt_info * dti,struct node * node)247 static void check_is_cell(struct check *c, struct dt_info *dti,
248 struct node *node)
249 {
250 struct property *prop;
251 char *propname = c->data;
252
253 prop = get_property(node, propname);
254 if (!prop)
255 return; /* Not present, assumed ok */
256
257 if (prop->val.len != sizeof(cell_t))
258 FAIL_PROP(c, dti, node, prop, "property is not a single cell");
259 }
260 #define WARNING_IF_NOT_CELL(nm, propname) \
261 WARNING(nm, check_is_cell, (propname))
262 #define ERROR_IF_NOT_CELL(nm, propname) \
263 ERROR(nm, check_is_cell, (propname))
264
265 /*
266 * Structural check functions
267 */
268
check_duplicate_node_names(struct check * c,struct dt_info * dti,struct node * node)269 static void check_duplicate_node_names(struct check *c, struct dt_info *dti,
270 struct node *node)
271 {
272 struct node *child, *child2;
273
274 for_each_child(node, child)
275 for (child2 = child->next_sibling;
276 child2;
277 child2 = child2->next_sibling)
278 if (streq(child->name, child2->name))
279 FAIL(c, dti, child2, "Duplicate node name");
280 }
281 ERROR(duplicate_node_names, check_duplicate_node_names, NULL);
282
check_duplicate_property_names(struct check * c,struct dt_info * dti,struct node * node)283 static void check_duplicate_property_names(struct check *c, struct dt_info *dti,
284 struct node *node)
285 {
286 struct property *prop, *prop2;
287
288 for_each_property(node, prop) {
289 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
290 if (prop2->deleted)
291 continue;
292 if (streq(prop->name, prop2->name))
293 FAIL_PROP(c, dti, node, prop, "Duplicate property name");
294 }
295 }
296 }
297 ERROR(duplicate_property_names, check_duplicate_property_names, NULL);
298
299 #define LOWERCASE "abcdefghijklmnopqrstuvwxyz"
300 #define UPPERCASE "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
301 #define DIGITS "0123456789"
302 #define PROPNODECHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-"
303 #define PROPNODECHARSSTRICT LOWERCASE UPPERCASE DIGITS ",-"
304
check_node_name_chars(struct check * c,struct dt_info * dti,struct node * node)305 static void check_node_name_chars(struct check *c, struct dt_info *dti,
306 struct node *node)
307 {
308 int n = strspn(node->name, c->data);
309
310 if (n < strlen(node->name))
311 FAIL(c, dti, node, "Bad character '%c' in node name",
312 node->name[n]);
313 }
314 ERROR(node_name_chars, check_node_name_chars, PROPNODECHARS "@");
315
check_node_name_chars_strict(struct check * c,struct dt_info * dti,struct node * node)316 static void check_node_name_chars_strict(struct check *c, struct dt_info *dti,
317 struct node *node)
318 {
319 int n = strspn(node->name, c->data);
320
321 if (n < node->basenamelen)
322 FAIL(c, dti, node, "Character '%c' not recommended in node name",
323 node->name[n]);
324 }
325 CHECK(node_name_chars_strict, check_node_name_chars_strict, PROPNODECHARSSTRICT);
326
check_node_name_format(struct check * c,struct dt_info * dti,struct node * node)327 static void check_node_name_format(struct check *c, struct dt_info *dti,
328 struct node *node)
329 {
330 if (strchr(get_unitname(node), '@'))
331 FAIL(c, dti, node, "multiple '@' characters in node name");
332 }
333 ERROR(node_name_format, check_node_name_format, NULL, &node_name_chars);
334
check_unit_address_vs_reg(struct check * c,struct dt_info * dti,struct node * node)335 static void check_unit_address_vs_reg(struct check *c, struct dt_info *dti,
336 struct node *node)
337 {
338 const char *unitname = get_unitname(node);
339 struct property *prop = get_property(node, "reg");
340
341 if (get_subnode(node, "__overlay__")) {
342 /* HACK: Overlay fragments are a special case */
343 return;
344 }
345
346 if (!prop) {
347 prop = get_property(node, "ranges");
348 if (prop && !prop->val.len)
349 prop = NULL;
350 }
351
352 if (prop) {
353 if (!unitname[0])
354 FAIL(c, dti, node, "node has a reg or ranges property, but no unit name");
355 } else {
356 if (unitname[0])
357 FAIL(c, dti, node, "node has a unit name, but no reg property");
358 }
359 }
360 WARNING(unit_address_vs_reg, check_unit_address_vs_reg, NULL);
361
check_property_name_chars(struct check * c,struct dt_info * dti,struct node * node)362 static void check_property_name_chars(struct check *c, struct dt_info *dti,
363 struct node *node)
364 {
365 struct property *prop;
366
367 for_each_property(node, prop) {
368 int n = strspn(prop->name, c->data);
369
370 if (n < strlen(prop->name))
371 FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name",
372 prop->name[n]);
373 }
374 }
375 ERROR(property_name_chars, check_property_name_chars, PROPNODECHARS);
376
check_property_name_chars_strict(struct check * c,struct dt_info * dti,struct node * node)377 static void check_property_name_chars_strict(struct check *c,
378 struct dt_info *dti,
379 struct node *node)
380 {
381 struct property *prop;
382
383 for_each_property(node, prop) {
384 const char *name = prop->name;
385 int n = strspn(name, c->data);
386
387 if (n == strlen(prop->name))
388 continue;
389
390 /* Certain names are whitelisted */
391 if (streq(name, "device_type"))
392 continue;
393
394 /*
395 * # is only allowed at the beginning of property names not counting
396 * the vendor prefix.
397 */
398 if (name[n] == '#' && ((n == 0) || (name[n-1] == ','))) {
399 name += n + 1;
400 n = strspn(name, c->data);
401 }
402 if (n < strlen(name))
403 FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name",
404 name[n]);
405 }
406 }
407 CHECK(property_name_chars_strict, check_property_name_chars_strict, PROPNODECHARSSTRICT);
408
409 #define DESCLABEL_FMT "%s%s%s%s%s"
410 #define DESCLABEL_ARGS(node,prop,mark) \
411 ((mark) ? "value of " : ""), \
412 ((prop) ? "'" : ""), \
413 ((prop) ? (prop)->name : ""), \
414 ((prop) ? "' in " : ""), (node)->fullpath
415
check_duplicate_label(struct check * c,struct dt_info * dti,const char * label,struct node * node,struct property * prop,struct marker * mark)416 static void check_duplicate_label(struct check *c, struct dt_info *dti,
417 const char *label, struct node *node,
418 struct property *prop, struct marker *mark)
419 {
420 struct node *dt = dti->dt;
421 struct node *othernode = NULL;
422 struct property *otherprop = NULL;
423 struct marker *othermark = NULL;
424
425 othernode = get_node_by_label(dt, label);
426
427 if (!othernode)
428 otherprop = get_property_by_label(dt, label, &othernode);
429 if (!othernode)
430 othermark = get_marker_label(dt, label, &othernode,
431 &otherprop);
432
433 if (!othernode)
434 return;
435
436 if ((othernode != node) || (otherprop != prop) || (othermark != mark))
437 FAIL(c, dti, node, "Duplicate label '%s' on " DESCLABEL_FMT
438 " and " DESCLABEL_FMT,
439 label, DESCLABEL_ARGS(node, prop, mark),
440 DESCLABEL_ARGS(othernode, otherprop, othermark));
441 }
442
check_duplicate_label_node(struct check * c,struct dt_info * dti,struct node * node)443 static void check_duplicate_label_node(struct check *c, struct dt_info *dti,
444 struct node *node)
445 {
446 struct label *l;
447 struct property *prop;
448
449 for_each_label(node->labels, l)
450 check_duplicate_label(c, dti, l->label, node, NULL, NULL);
451
452 for_each_property(node, prop) {
453 struct marker *m = prop->val.markers;
454
455 for_each_label(prop->labels, l)
456 check_duplicate_label(c, dti, l->label, node, prop, NULL);
457
458 for_each_marker_of_type(m, LABEL)
459 check_duplicate_label(c, dti, m->ref, node, prop, m);
460 }
461 }
462 ERROR(duplicate_label, check_duplicate_label_node, NULL);
463
check_phandle_prop(struct check * c,struct dt_info * dti,struct node * node,const char * propname)464 static cell_t check_phandle_prop(struct check *c, struct dt_info *dti,
465 struct node *node, const char *propname)
466 {
467 struct node *root = dti->dt;
468 struct property *prop;
469 struct marker *m;
470 cell_t phandle;
471
472 prop = get_property(node, propname);
473 if (!prop)
474 return 0;
475
476 if (prop->val.len != sizeof(cell_t)) {
477 FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property",
478 prop->val.len, prop->name);
479 return 0;
480 }
481
482 m = prop->val.markers;
483 for_each_marker_of_type(m, REF_PHANDLE) {
484 assert(m->offset == 0);
485 if (node != get_node_by_ref(root, m->ref))
486 /* "Set this node's phandle equal to some
487 * other node's phandle". That's nonsensical
488 * by construction. */ {
489 FAIL(c, dti, node, "%s is a reference to another node",
490 prop->name);
491 }
492 /* But setting this node's phandle equal to its own
493 * phandle is allowed - that means allocate a unique
494 * phandle for this node, even if it's not otherwise
495 * referenced. The value will be filled in later, so
496 * we treat it as having no phandle data for now. */
497 return 0;
498 }
499
500 phandle = propval_cell(prop);
501
502 if ((phandle == 0) || (phandle == -1)) {
503 FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property",
504 phandle, prop->name);
505 return 0;
506 }
507
508 return phandle;
509 }
510
check_explicit_phandles(struct check * c,struct dt_info * dti,struct node * node)511 static void check_explicit_phandles(struct check *c, struct dt_info *dti,
512 struct node *node)
513 {
514 struct node *root = dti->dt;
515 struct node *other;
516 cell_t phandle, linux_phandle;
517
518 /* Nothing should have assigned phandles yet */
519 assert(!node->phandle);
520
521 phandle = check_phandle_prop(c, dti, node, "phandle");
522
523 linux_phandle = check_phandle_prop(c, dti, node, "linux,phandle");
524
525 if (!phandle && !linux_phandle)
526 /* No valid phandles; nothing further to check */
527 return;
528
529 if (linux_phandle && phandle && (phandle != linux_phandle))
530 FAIL(c, dti, node, "mismatching 'phandle' and 'linux,phandle'"
531 " properties");
532
533 if (linux_phandle && !phandle)
534 phandle = linux_phandle;
535
536 other = get_node_by_phandle(root, phandle);
537 if (other && (other != node)) {
538 FAIL(c, dti, node, "duplicated phandle 0x%x (seen before at %s)",
539 phandle, other->fullpath);
540 return;
541 }
542
543 node->phandle = phandle;
544 }
545 ERROR(explicit_phandles, check_explicit_phandles, NULL);
546
check_name_properties(struct check * c,struct dt_info * dti,struct node * node)547 static void check_name_properties(struct check *c, struct dt_info *dti,
548 struct node *node)
549 {
550 struct property **pp, *prop = NULL;
551
552 for (pp = &node->proplist; *pp; pp = &((*pp)->next))
553 if (streq((*pp)->name, "name")) {
554 prop = *pp;
555 break;
556 }
557
558 if (!prop)
559 return; /* No name property, that's fine */
560
561 if ((prop->val.len != node->basenamelen+1)
562 || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
563 FAIL(c, dti, node, "\"name\" property is incorrect (\"%s\" instead"
564 " of base node name)", prop->val.val);
565 } else {
566 /* The name property is correct, and therefore redundant.
567 * Delete it */
568 *pp = prop->next;
569 free(prop->name);
570 data_free(prop->val);
571 free(prop);
572 }
573 }
574 ERROR_IF_NOT_STRING(name_is_string, "name");
575 ERROR(name_properties, check_name_properties, NULL, &name_is_string);
576
577 /*
578 * Reference fixup functions
579 */
580
fixup_phandle_references(struct check * c,struct dt_info * dti,struct node * node)581 static void fixup_phandle_references(struct check *c, struct dt_info *dti,
582 struct node *node)
583 {
584 struct node *dt = dti->dt;
585 struct property *prop;
586
587 for_each_property(node, prop) {
588 struct marker *m = prop->val.markers;
589 struct node *refnode;
590 cell_t phandle;
591
592 for_each_marker_of_type(m, REF_PHANDLE) {
593 assert(m->offset + sizeof(cell_t) <= prop->val.len);
594
595 refnode = get_node_by_ref(dt, m->ref);
596 if (! refnode) {
597 if (!(dti->dtsflags & DTSF_PLUGIN))
598 FAIL(c, dti, node, "Reference to non-existent node or "
599 "label \"%s\"\n", m->ref);
600 else /* mark the entry as unresolved */
601 *((fdt32_t *)(prop->val.val + m->offset)) =
602 cpu_to_fdt32(0xffffffff);
603 continue;
604 }
605
606 phandle = get_node_phandle(dt, refnode);
607 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
608
609 reference_node(refnode);
610 }
611 }
612 }
613 ERROR(phandle_references, fixup_phandle_references, NULL,
614 &duplicate_node_names, &explicit_phandles);
615
fixup_path_references(struct check * c,struct dt_info * dti,struct node * node)616 static void fixup_path_references(struct check *c, struct dt_info *dti,
617 struct node *node)
618 {
619 struct node *dt = dti->dt;
620 struct property *prop;
621
622 for_each_property(node, prop) {
623 struct marker *m = prop->val.markers;
624 struct node *refnode;
625 char *path;
626
627 for_each_marker_of_type(m, REF_PATH) {
628 assert(m->offset <= prop->val.len);
629
630 refnode = get_node_by_ref(dt, m->ref);
631 if (!refnode) {
632 FAIL(c, dti, node, "Reference to non-existent node or label \"%s\"\n",
633 m->ref);
634 continue;
635 }
636
637 path = refnode->fullpath;
638 prop->val = data_insert_at_marker(prop->val, m, path,
639 strlen(path) + 1);
640
641 reference_node(refnode);
642 }
643 }
644 }
645 ERROR(path_references, fixup_path_references, NULL, &duplicate_node_names);
646
fixup_omit_unused_nodes(struct check * c,struct dt_info * dti,struct node * node)647 static void fixup_omit_unused_nodes(struct check *c, struct dt_info *dti,
648 struct node *node)
649 {
650 if (generate_symbols && node->labels)
651 return;
652 if (node->omit_if_unused && !node->is_referenced)
653 delete_node(node);
654 }
655 ERROR(omit_unused_nodes, fixup_omit_unused_nodes, NULL, &phandle_references, &path_references);
656
657 /*
658 * Semantic checks
659 */
660 WARNING_IF_NOT_CELL(address_cells_is_cell, "#address-cells");
661 WARNING_IF_NOT_CELL(size_cells_is_cell, "#size-cells");
662 WARNING_IF_NOT_CELL(interrupt_cells_is_cell, "#interrupt-cells");
663
664 WARNING_IF_NOT_STRING(device_type_is_string, "device_type");
665 WARNING_IF_NOT_STRING(model_is_string, "model");
666 WARNING_IF_NOT_STRING(status_is_string, "status");
667 WARNING_IF_NOT_STRING(label_is_string, "label");
668
669 WARNING_IF_NOT_STRING_LIST(compatible_is_string_list, "compatible");
670
check_names_is_string_list(struct check * c,struct dt_info * dti,struct node * node)671 static void check_names_is_string_list(struct check *c, struct dt_info *dti,
672 struct node *node)
673 {
674 struct property *prop;
675
676 for_each_property(node, prop) {
677 const char *s = strrchr(prop->name, '-');
678 if (!s || !streq(s, "-names"))
679 continue;
680
681 c->data = prop->name;
682 check_is_string_list(c, dti, node);
683 }
684 }
685 WARNING(names_is_string_list, check_names_is_string_list, NULL);
686
check_alias_paths(struct check * c,struct dt_info * dti,struct node * node)687 static void check_alias_paths(struct check *c, struct dt_info *dti,
688 struct node *node)
689 {
690 struct property *prop;
691
692 if (!streq(node->name, "aliases"))
693 return;
694
695 for_each_property(node, prop) {
696 if (streq(prop->name, "phandle")
697 || streq(prop->name, "linux,phandle")) {
698 continue;
699 }
700
701 if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) {
702 FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)",
703 prop->val.val);
704 continue;
705 }
706 if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name))
707 FAIL(c, dti, node, "aliases property name must include only lowercase and '-'");
708 }
709 }
710 WARNING(alias_paths, check_alias_paths, NULL);
711
fixup_addr_size_cells(struct check * c,struct dt_info * dti,struct node * node)712 static void fixup_addr_size_cells(struct check *c, struct dt_info *dti,
713 struct node *node)
714 {
715 struct property *prop;
716
717 node->addr_cells = -1;
718 node->size_cells = -1;
719
720 prop = get_property(node, "#address-cells");
721 if (prop)
722 node->addr_cells = propval_cell(prop);
723
724 prop = get_property(node, "#size-cells");
725 if (prop)
726 node->size_cells = propval_cell(prop);
727 }
728 WARNING(addr_size_cells, fixup_addr_size_cells, NULL,
729 &address_cells_is_cell, &size_cells_is_cell);
730
731 #define node_addr_cells(n) \
732 (((n)->addr_cells == -1) ? 2 : (n)->addr_cells)
733 #define node_size_cells(n) \
734 (((n)->size_cells == -1) ? 1 : (n)->size_cells)
735
check_reg_format(struct check * c,struct dt_info * dti,struct node * node)736 static void check_reg_format(struct check *c, struct dt_info *dti,
737 struct node *node)
738 {
739 struct property *prop;
740 int addr_cells, size_cells, entrylen;
741
742 prop = get_property(node, "reg");
743 if (!prop)
744 return; /* No "reg", that's fine */
745
746 if (!node->parent) {
747 FAIL(c, dti, node, "Root node has a \"reg\" property");
748 return;
749 }
750
751 if (prop->val.len == 0)
752 FAIL_PROP(c, dti, node, prop, "property is empty");
753
754 addr_cells = node_addr_cells(node->parent);
755 size_cells = node_size_cells(node->parent);
756 entrylen = (addr_cells + size_cells) * sizeof(cell_t);
757
758 if (!entrylen || (prop->val.len % entrylen) != 0)
759 FAIL_PROP(c, dti, node, prop, "property has invalid length (%d bytes) "
760 "(#address-cells == %d, #size-cells == %d)",
761 prop->val.len, addr_cells, size_cells);
762 }
763 WARNING(reg_format, check_reg_format, NULL, &addr_size_cells);
764
check_ranges_format(struct check * c,struct dt_info * dti,struct node * node)765 static void check_ranges_format(struct check *c, struct dt_info *dti,
766 struct node *node)
767 {
768 struct property *prop;
769 int c_addr_cells, p_addr_cells, c_size_cells, p_size_cells, entrylen;
770
771 prop = get_property(node, "ranges");
772 if (!prop)
773 return;
774
775 if (!node->parent) {
776 FAIL_PROP(c, dti, node, prop, "Root node has a \"ranges\" property");
777 return;
778 }
779
780 p_addr_cells = node_addr_cells(node->parent);
781 p_size_cells = node_size_cells(node->parent);
782 c_addr_cells = node_addr_cells(node);
783 c_size_cells = node_size_cells(node);
784 entrylen = (p_addr_cells + c_addr_cells + c_size_cells) * sizeof(cell_t);
785
786 if (prop->val.len == 0) {
787 if (p_addr_cells != c_addr_cells)
788 FAIL_PROP(c, dti, node, prop, "empty \"ranges\" property but its "
789 "#address-cells (%d) differs from %s (%d)",
790 c_addr_cells, node->parent->fullpath,
791 p_addr_cells);
792 if (p_size_cells != c_size_cells)
793 FAIL_PROP(c, dti, node, prop, "empty \"ranges\" property but its "
794 "#size-cells (%d) differs from %s (%d)",
795 c_size_cells, node->parent->fullpath,
796 p_size_cells);
797 } else if ((prop->val.len % entrylen) != 0) {
798 FAIL_PROP(c, dti, node, prop, "\"ranges\" property has invalid length (%d bytes) "
799 "(parent #address-cells == %d, child #address-cells == %d, "
800 "#size-cells == %d)", prop->val.len,
801 p_addr_cells, c_addr_cells, c_size_cells);
802 }
803 }
804 WARNING(ranges_format, check_ranges_format, NULL, &addr_size_cells);
805
806 static const struct bus_type pci_bus = {
807 .name = "PCI",
808 };
809
check_pci_bridge(struct check * c,struct dt_info * dti,struct node * node)810 static void check_pci_bridge(struct check *c, struct dt_info *dti, struct node *node)
811 {
812 struct property *prop;
813 cell_t *cells;
814
815 prop = get_property(node, "device_type");
816 if (!prop || !streq(prop->val.val, "pci"))
817 return;
818
819 node->bus = &pci_bus;
820
821 if (!strprefixeq(node->name, node->basenamelen, "pci") &&
822 !strprefixeq(node->name, node->basenamelen, "pcie"))
823 FAIL(c, dti, node, "node name is not \"pci\" or \"pcie\"");
824
825 prop = get_property(node, "ranges");
826 if (!prop)
827 FAIL(c, dti, node, "missing ranges for PCI bridge (or not a bridge)");
828
829 if (node_addr_cells(node) != 3)
830 FAIL(c, dti, node, "incorrect #address-cells for PCI bridge");
831 if (node_size_cells(node) != 2)
832 FAIL(c, dti, node, "incorrect #size-cells for PCI bridge");
833
834 prop = get_property(node, "bus-range");
835 if (!prop)
836 return;
837
838 if (prop->val.len != (sizeof(cell_t) * 2)) {
839 FAIL_PROP(c, dti, node, prop, "value must be 2 cells");
840 return;
841 }
842 cells = (cell_t *)prop->val.val;
843 if (fdt32_to_cpu(cells[0]) > fdt32_to_cpu(cells[1]))
844 FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell");
845 if (fdt32_to_cpu(cells[1]) > 0xff)
846 FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256");
847 }
848 WARNING(pci_bridge, check_pci_bridge, NULL,
849 &device_type_is_string, &addr_size_cells);
850
check_pci_device_bus_num(struct check * c,struct dt_info * dti,struct node * node)851 static void check_pci_device_bus_num(struct check *c, struct dt_info *dti, struct node *node)
852 {
853 struct property *prop;
854 unsigned int bus_num, min_bus, max_bus;
855 cell_t *cells;
856
857 if (!node->parent || (node->parent->bus != &pci_bus))
858 return;
859
860 prop = get_property(node, "reg");
861 if (!prop)
862 return;
863
864 cells = (cell_t *)prop->val.val;
865 bus_num = (fdt32_to_cpu(cells[0]) & 0x00ff0000) >> 16;
866
867 prop = get_property(node->parent, "bus-range");
868 if (!prop) {
869 min_bus = max_bus = 0;
870 } else {
871 cells = (cell_t *)prop->val.val;
872 min_bus = fdt32_to_cpu(cells[0]);
873 max_bus = fdt32_to_cpu(cells[0]);
874 }
875 if ((bus_num < min_bus) || (bus_num > max_bus))
876 FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)",
877 bus_num, min_bus, max_bus);
878 }
879 WARNING(pci_device_bus_num, check_pci_device_bus_num, NULL, ®_format, &pci_bridge);
880
check_pci_device_reg(struct check * c,struct dt_info * dti,struct node * node)881 static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct node *node)
882 {
883 struct property *prop;
884 const char *unitname = get_unitname(node);
885 char unit_addr[5];
886 unsigned int dev, func, reg;
887 cell_t *cells;
888
889 if (!node->parent || (node->parent->bus != &pci_bus))
890 return;
891
892 prop = get_property(node, "reg");
893 if (!prop) {
894 FAIL(c, dti, node, "missing PCI reg property");
895 return;
896 }
897
898 cells = (cell_t *)prop->val.val;
899 if (cells[1] || cells[2])
900 FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0");
901
902 reg = fdt32_to_cpu(cells[0]);
903 dev = (reg & 0xf800) >> 11;
904 func = (reg & 0x700) >> 8;
905
906 if (reg & 0xff000000)
907 FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space");
908 if (reg & 0x000000ff)
909 FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0");
910
911 if (func == 0) {
912 snprintf(unit_addr, sizeof(unit_addr), "%x", dev);
913 if (streq(unitname, unit_addr))
914 return;
915 }
916
917 snprintf(unit_addr, sizeof(unit_addr), "%x,%x", dev, func);
918 if (streq(unitname, unit_addr))
919 return;
920
921 FAIL(c, dti, node, "PCI unit address format error, expected \"%s\"",
922 unit_addr);
923 }
924 WARNING(pci_device_reg, check_pci_device_reg, NULL, ®_format, &pci_bridge);
925
926 static const struct bus_type simple_bus = {
927 .name = "simple-bus",
928 };
929
node_is_compatible(struct node * node,const char * compat)930 static bool node_is_compatible(struct node *node, const char *compat)
931 {
932 struct property *prop;
933 const char *str, *end;
934
935 prop = get_property(node, "compatible");
936 if (!prop)
937 return false;
938
939 for (str = prop->val.val, end = str + prop->val.len; str < end;
940 str += strnlen(str, end - str) + 1) {
941 if (streq(str, compat))
942 return true;
943 }
944 return false;
945 }
946
check_simple_bus_bridge(struct check * c,struct dt_info * dti,struct node * node)947 static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
948 {
949 if (node_is_compatible(node, "simple-bus"))
950 node->bus = &simple_bus;
951 }
952 WARNING(simple_bus_bridge, check_simple_bus_bridge, NULL,
953 &addr_size_cells, &compatible_is_string_list);
954
check_simple_bus_reg(struct check * c,struct dt_info * dti,struct node * node)955 static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
956 {
957 struct property *prop;
958 const char *unitname = get_unitname(node);
959 char unit_addr[17];
960 unsigned int size;
961 uint64_t reg = 0;
962 cell_t *cells = NULL;
963
964 if (!node->parent || (node->parent->bus != &simple_bus))
965 return;
966
967 prop = get_property(node, "reg");
968 if (prop)
969 cells = (cell_t *)prop->val.val;
970 else {
971 prop = get_property(node, "ranges");
972 if (prop && prop->val.len)
973 /* skip of child address */
974 cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
975 }
976
977 if (!cells) {
978 if (node->parent->parent && !(node->bus == &simple_bus))
979 FAIL(c, dti, node, "missing or empty reg/ranges property");
980 return;
981 }
982
983 size = node_addr_cells(node->parent);
984 while (size--)
985 reg = (reg << 32) | fdt32_to_cpu(*(cells++));
986
987 snprintf(unit_addr, sizeof(unit_addr), "%"PRIx64, reg);
988 if (!streq(unitname, unit_addr))
989 FAIL(c, dti, node, "simple-bus unit address format error, expected \"%s\"",
990 unit_addr);
991 }
992 WARNING(simple_bus_reg, check_simple_bus_reg, NULL, ®_format, &simple_bus_bridge);
993
994 static const struct bus_type i2c_bus = {
995 .name = "i2c-bus",
996 };
997
check_i2c_bus_bridge(struct check * c,struct dt_info * dti,struct node * node)998 static void check_i2c_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
999 {
1000 if (strprefixeq(node->name, node->basenamelen, "i2c-bus") ||
1001 strprefixeq(node->name, node->basenamelen, "i2c-arb")) {
1002 node->bus = &i2c_bus;
1003 } else if (strprefixeq(node->name, node->basenamelen, "i2c")) {
1004 struct node *child;
1005 for_each_child(node, child) {
1006 if (strprefixeq(child->name, node->basenamelen, "i2c-bus"))
1007 return;
1008 }
1009 node->bus = &i2c_bus;
1010 } else
1011 return;
1012
1013 if (!node->children)
1014 return;
1015
1016 if (node_addr_cells(node) != 1)
1017 FAIL(c, dti, node, "incorrect #address-cells for I2C bus");
1018 if (node_size_cells(node) != 0)
1019 FAIL(c, dti, node, "incorrect #size-cells for I2C bus");
1020
1021 }
1022 WARNING(i2c_bus_bridge, check_i2c_bus_bridge, NULL, &addr_size_cells);
1023
check_i2c_bus_reg(struct check * c,struct dt_info * dti,struct node * node)1024 static void check_i2c_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
1025 {
1026 struct property *prop;
1027 const char *unitname = get_unitname(node);
1028 char unit_addr[17];
1029 uint32_t reg = 0;
1030 int len;
1031 cell_t *cells = NULL;
1032
1033 if (!node->parent || (node->parent->bus != &i2c_bus))
1034 return;
1035
1036 prop = get_property(node, "reg");
1037 if (prop)
1038 cells = (cell_t *)prop->val.val;
1039
1040 if (!cells) {
1041 FAIL(c, dti, node, "missing or empty reg property");
1042 return;
1043 }
1044
1045 reg = fdt32_to_cpu(*cells);
1046 snprintf(unit_addr, sizeof(unit_addr), "%x", reg);
1047 if (!streq(unitname, unit_addr))
1048 FAIL(c, dti, node, "I2C bus unit address format error, expected \"%s\"",
1049 unit_addr);
1050
1051 for (len = prop->val.len; len > 0; len -= 4) {
1052 reg = fdt32_to_cpu(*(cells++));
1053 if (reg > 0x3ff)
1054 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 10-bits, got \"0x%x\"",
1055 reg);
1056
1057 }
1058 }
1059 WARNING(i2c_bus_reg, check_i2c_bus_reg, NULL, ®_format, &i2c_bus_bridge);
1060
1061 static const struct bus_type spi_bus = {
1062 .name = "spi-bus",
1063 };
1064
check_spi_bus_bridge(struct check * c,struct dt_info * dti,struct node * node)1065 static void check_spi_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
1066 {
1067 int spi_addr_cells = 1;
1068
1069 if (strprefixeq(node->name, node->basenamelen, "spi")) {
1070 node->bus = &spi_bus;
1071 } else {
1072 /* Try to detect SPI buses which don't have proper node name */
1073 struct node *child;
1074
1075 if (node_addr_cells(node) != 1 || node_size_cells(node) != 0)
1076 return;
1077
1078 for_each_child(node, child) {
1079 struct property *prop;
1080 for_each_property(child, prop) {
1081 if (strprefixeq(prop->name, 4, "spi-")) {
1082 node->bus = &spi_bus;
1083 break;
1084 }
1085 }
1086 if (node->bus == &spi_bus)
1087 break;
1088 }
1089
1090 if (node->bus == &spi_bus && get_property(node, "reg"))
1091 FAIL(c, dti, node, "node name for SPI buses should be 'spi'");
1092 }
1093 if (node->bus != &spi_bus || !node->children)
1094 return;
1095
1096 if (get_property(node, "spi-slave"))
1097 spi_addr_cells = 0;
1098 if (node_addr_cells(node) != spi_addr_cells)
1099 FAIL(c, dti, node, "incorrect #address-cells for SPI bus");
1100 if (node_size_cells(node) != 0)
1101 FAIL(c, dti, node, "incorrect #size-cells for SPI bus");
1102
1103 }
1104 WARNING(spi_bus_bridge, check_spi_bus_bridge, NULL, &addr_size_cells);
1105
check_spi_bus_reg(struct check * c,struct dt_info * dti,struct node * node)1106 static void check_spi_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
1107 {
1108 struct property *prop;
1109 const char *unitname = get_unitname(node);
1110 char unit_addr[9];
1111 uint32_t reg = 0;
1112 cell_t *cells = NULL;
1113
1114 if (!node->parent || (node->parent->bus != &spi_bus))
1115 return;
1116
1117 if (get_property(node->parent, "spi-slave"))
1118 return;
1119
1120 prop = get_property(node, "reg");
1121 if (prop)
1122 cells = (cell_t *)prop->val.val;
1123
1124 if (!cells) {
1125 FAIL(c, dti, node, "missing or empty reg property");
1126 return;
1127 }
1128
1129 reg = fdt32_to_cpu(*cells);
1130 snprintf(unit_addr, sizeof(unit_addr), "%x", reg);
1131 if (!streq(unitname, unit_addr))
1132 FAIL(c, dti, node, "SPI bus unit address format error, expected \"%s\"",
1133 unit_addr);
1134 }
1135 WARNING(spi_bus_reg, check_spi_bus_reg, NULL, ®_format, &spi_bus_bridge);
1136
check_unit_address_format(struct check * c,struct dt_info * dti,struct node * node)1137 static void check_unit_address_format(struct check *c, struct dt_info *dti,
1138 struct node *node)
1139 {
1140 const char *unitname = get_unitname(node);
1141
1142 if (node->parent && node->parent->bus)
1143 return;
1144
1145 if (!unitname[0])
1146 return;
1147
1148 if (!strncmp(unitname, "0x", 2)) {
1149 FAIL(c, dti, node, "unit name should not have leading \"0x\"");
1150 /* skip over 0x for next test */
1151 unitname += 2;
1152 }
1153 if (unitname[0] == '0' && isxdigit(unitname[1]))
1154 FAIL(c, dti, node, "unit name should not have leading 0s");
1155 }
1156 WARNING(unit_address_format, check_unit_address_format, NULL,
1157 &node_name_format, &pci_bridge, &simple_bus_bridge);
1158
1159 /*
1160 * Style checks
1161 */
check_avoid_default_addr_size(struct check * c,struct dt_info * dti,struct node * node)1162 static void check_avoid_default_addr_size(struct check *c, struct dt_info *dti,
1163 struct node *node)
1164 {
1165 struct property *reg, *ranges;
1166
1167 if (!node->parent)
1168 return; /* Ignore root node */
1169
1170 reg = get_property(node, "reg");
1171 ranges = get_property(node, "ranges");
1172
1173 if (!reg && !ranges)
1174 return;
1175
1176 if (node->parent->addr_cells == -1)
1177 FAIL(c, dti, node, "Relying on default #address-cells value");
1178
1179 if (node->parent->size_cells == -1)
1180 FAIL(c, dti, node, "Relying on default #size-cells value");
1181 }
1182 WARNING(avoid_default_addr_size, check_avoid_default_addr_size, NULL,
1183 &addr_size_cells);
1184
check_avoid_unnecessary_addr_size(struct check * c,struct dt_info * dti,struct node * node)1185 static void check_avoid_unnecessary_addr_size(struct check *c, struct dt_info *dti,
1186 struct node *node)
1187 {
1188 struct property *prop;
1189 struct node *child;
1190 bool has_reg = false;
1191
1192 if (!node->parent || node->addr_cells < 0 || node->size_cells < 0)
1193 return;
1194
1195 if (get_property(node, "ranges") || !node->children)
1196 return;
1197
1198 for_each_child(node, child) {
1199 prop = get_property(child, "reg");
1200 if (prop)
1201 has_reg = true;
1202 }
1203
1204 if (!has_reg)
1205 FAIL(c, dti, node, "unnecessary #address-cells/#size-cells without \"ranges\" or child \"reg\" property");
1206 }
1207 WARNING(avoid_unnecessary_addr_size, check_avoid_unnecessary_addr_size, NULL, &avoid_default_addr_size);
1208
node_is_disabled(struct node * node)1209 static bool node_is_disabled(struct node *node)
1210 {
1211 struct property *prop;
1212
1213 prop = get_property(node, "status");
1214 if (prop) {
1215 char *str = prop->val.val;
1216 if (streq("disabled", str))
1217 return true;
1218 }
1219
1220 return false;
1221 }
1222
check_unique_unit_address_common(struct check * c,struct dt_info * dti,struct node * node,bool disable_check)1223 static void check_unique_unit_address_common(struct check *c,
1224 struct dt_info *dti,
1225 struct node *node,
1226 bool disable_check)
1227 {
1228 struct node *childa;
1229
1230 if (node->addr_cells < 0 || node->size_cells < 0)
1231 return;
1232
1233 if (!node->children)
1234 return;
1235
1236 for_each_child(node, childa) {
1237 struct node *childb;
1238 const char *addr_a = get_unitname(childa);
1239
1240 if (!strlen(addr_a))
1241 continue;
1242
1243 if (disable_check && node_is_disabled(childa))
1244 continue;
1245
1246 for_each_child(node, childb) {
1247 const char *addr_b = get_unitname(childb);
1248 if (childa == childb)
1249 break;
1250
1251 if (disable_check && node_is_disabled(childb))
1252 continue;
1253
1254 if (streq(addr_a, addr_b))
1255 FAIL(c, dti, childb, "duplicate unit-address (also used in node %s)", childa->fullpath);
1256 }
1257 }
1258 }
1259
check_unique_unit_address(struct check * c,struct dt_info * dti,struct node * node)1260 static void check_unique_unit_address(struct check *c, struct dt_info *dti,
1261 struct node *node)
1262 {
1263 check_unique_unit_address_common(c, dti, node, false);
1264 }
1265 WARNING(unique_unit_address, check_unique_unit_address, NULL, &avoid_default_addr_size);
1266
check_unique_unit_address_if_enabled(struct check * c,struct dt_info * dti,struct node * node)1267 static void check_unique_unit_address_if_enabled(struct check *c, struct dt_info *dti,
1268 struct node *node)
1269 {
1270 check_unique_unit_address_common(c, dti, node, true);
1271 }
1272 CHECK_ENTRY(unique_unit_address_if_enabled, check_unique_unit_address_if_enabled,
1273 NULL, false, false, &avoid_default_addr_size);
1274
check_obsolete_chosen_interrupt_controller(struct check * c,struct dt_info * dti,struct node * node)1275 static void check_obsolete_chosen_interrupt_controller(struct check *c,
1276 struct dt_info *dti,
1277 struct node *node)
1278 {
1279 struct node *dt = dti->dt;
1280 struct node *chosen;
1281 struct property *prop;
1282
1283 if (node != dt)
1284 return;
1285
1286
1287 chosen = get_node_by_path(dt, "/chosen");
1288 if (!chosen)
1289 return;
1290
1291 prop = get_property(chosen, "interrupt-controller");
1292 if (prop)
1293 FAIL_PROP(c, dti, node, prop,
1294 "/chosen has obsolete \"interrupt-controller\" property");
1295 }
1296 WARNING(obsolete_chosen_interrupt_controller,
1297 check_obsolete_chosen_interrupt_controller, NULL);
1298
check_chosen_node_is_root(struct check * c,struct dt_info * dti,struct node * node)1299 static void check_chosen_node_is_root(struct check *c, struct dt_info *dti,
1300 struct node *node)
1301 {
1302 if (!streq(node->name, "chosen"))
1303 return;
1304
1305 if (node->parent != dti->dt)
1306 FAIL(c, dti, node, "chosen node must be at root node");
1307 }
1308 WARNING(chosen_node_is_root, check_chosen_node_is_root, NULL);
1309
check_chosen_node_bootargs(struct check * c,struct dt_info * dti,struct node * node)1310 static void check_chosen_node_bootargs(struct check *c, struct dt_info *dti,
1311 struct node *node)
1312 {
1313 struct property *prop;
1314
1315 if (!streq(node->name, "chosen"))
1316 return;
1317
1318 prop = get_property(node, "bootargs");
1319 if (!prop)
1320 return;
1321
1322 c->data = prop->name;
1323 check_is_string(c, dti, node);
1324 }
1325 WARNING(chosen_node_bootargs, check_chosen_node_bootargs, NULL);
1326
check_chosen_node_stdout_path(struct check * c,struct dt_info * dti,struct node * node)1327 static void check_chosen_node_stdout_path(struct check *c, struct dt_info *dti,
1328 struct node *node)
1329 {
1330 struct property *prop;
1331
1332 if (!streq(node->name, "chosen"))
1333 return;
1334
1335 prop = get_property(node, "stdout-path");
1336 if (!prop) {
1337 prop = get_property(node, "linux,stdout-path");
1338 if (!prop)
1339 return;
1340 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead");
1341 }
1342
1343 c->data = prop->name;
1344 check_is_string(c, dti, node);
1345 }
1346 WARNING(chosen_node_stdout_path, check_chosen_node_stdout_path, NULL);
1347
1348 struct provider {
1349 const char *prop_name;
1350 const char *cell_name;
1351 bool optional;
1352 };
1353
check_property_phandle_args(struct check * c,struct dt_info * dti,struct node * node,struct property * prop,const struct provider * provider)1354 static void check_property_phandle_args(struct check *c,
1355 struct dt_info *dti,
1356 struct node *node,
1357 struct property *prop,
1358 const struct provider *provider)
1359 {
1360 struct node *root = dti->dt;
1361 int cell, cellsize = 0;
1362
1363 if (prop->val.len % sizeof(cell_t)) {
1364 FAIL_PROP(c, dti, node, prop,
1365 "property size (%d) is invalid, expected multiple of %zu",
1366 prop->val.len, sizeof(cell_t));
1367 return;
1368 }
1369
1370 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {
1371 struct node *provider_node;
1372 struct property *cellprop;
1373 int phandle;
1374
1375 phandle = propval_cell_n(prop, cell);
1376 /*
1377 * Some bindings use a cell value 0 or -1 to skip over optional
1378 * entries when each index position has a specific definition.
1379 */
1380 if (phandle == 0 || phandle == -1) {
1381 /* Give up if this is an overlay with external references */
1382 if (dti->dtsflags & DTSF_PLUGIN)
1383 break;
1384
1385 cellsize = 0;
1386 continue;
1387 }
1388
1389 /* If we have markers, verify the current cell is a phandle */
1390 if (prop->val.markers) {
1391 struct marker *m = prop->val.markers;
1392 for_each_marker_of_type(m, REF_PHANDLE) {
1393 if (m->offset == (cell * sizeof(cell_t)))
1394 break;
1395 }
1396 if (!m)
1397 FAIL_PROP(c, dti, node, prop,
1398 "cell %d is not a phandle reference",
1399 cell);
1400 }
1401
1402 provider_node = get_node_by_phandle(root, phandle);
1403 if (!provider_node) {
1404 FAIL_PROP(c, dti, node, prop,
1405 "Could not get phandle node for (cell %d)",
1406 cell);
1407 break;
1408 }
1409
1410 cellprop = get_property(provider_node, provider->cell_name);
1411 if (cellprop) {
1412 cellsize = propval_cell(cellprop);
1413 } else if (provider->optional) {
1414 cellsize = 0;
1415 } else {
1416 FAIL(c, dti, node, "Missing property '%s' in node %s or bad phandle (referred from %s[%d])",
1417 provider->cell_name,
1418 provider_node->fullpath,
1419 prop->name, cell);
1420 break;
1421 }
1422
1423 if (prop->val.len < ((cell + cellsize + 1) * sizeof(cell_t))) {
1424 FAIL_PROP(c, dti, node, prop,
1425 "property size (%d) too small for cell size %d",
1426 prop->val.len, cellsize);
1427 }
1428 }
1429 }
1430
check_provider_cells_property(struct check * c,struct dt_info * dti,struct node * node)1431 static void check_provider_cells_property(struct check *c,
1432 struct dt_info *dti,
1433 struct node *node)
1434 {
1435 struct provider *provider = c->data;
1436 struct property *prop;
1437
1438 prop = get_property(node, provider->prop_name);
1439 if (!prop)
1440 return;
1441
1442 check_property_phandle_args(c, dti, node, prop, provider);
1443 }
1444 #define WARNING_PROPERTY_PHANDLE_CELLS(nm, propname, cells_name, ...) \
1445 static struct provider nm##_provider = { (propname), (cells_name), __VA_ARGS__ }; \
1446 WARNING(nm##_property, check_provider_cells_property, &nm##_provider, &phandle_references);
1447
1448 WARNING_PROPERTY_PHANDLE_CELLS(clocks, "clocks", "#clock-cells");
1449 WARNING_PROPERTY_PHANDLE_CELLS(cooling_device, "cooling-device", "#cooling-cells");
1450 WARNING_PROPERTY_PHANDLE_CELLS(dmas, "dmas", "#dma-cells");
1451 WARNING_PROPERTY_PHANDLE_CELLS(hwlocks, "hwlocks", "#hwlock-cells");
1452 WARNING_PROPERTY_PHANDLE_CELLS(interrupts_extended, "interrupts-extended", "#interrupt-cells");
1453 WARNING_PROPERTY_PHANDLE_CELLS(io_channels, "io-channels", "#io-channel-cells");
1454 WARNING_PROPERTY_PHANDLE_CELLS(iommus, "iommus", "#iommu-cells");
1455 WARNING_PROPERTY_PHANDLE_CELLS(mboxes, "mboxes", "#mbox-cells");
1456 WARNING_PROPERTY_PHANDLE_CELLS(msi_parent, "msi-parent", "#msi-cells", true);
1457 WARNING_PROPERTY_PHANDLE_CELLS(mux_controls, "mux-controls", "#mux-control-cells");
1458 WARNING_PROPERTY_PHANDLE_CELLS(phys, "phys", "#phy-cells");
1459 WARNING_PROPERTY_PHANDLE_CELLS(power_domains, "power-domains", "#power-domain-cells");
1460 WARNING_PROPERTY_PHANDLE_CELLS(pwms, "pwms", "#pwm-cells");
1461 WARNING_PROPERTY_PHANDLE_CELLS(resets, "resets", "#reset-cells");
1462 WARNING_PROPERTY_PHANDLE_CELLS(sound_dai, "sound-dai", "#sound-dai-cells");
1463 WARNING_PROPERTY_PHANDLE_CELLS(thermal_sensors, "thermal-sensors", "#thermal-sensor-cells");
1464
prop_is_gpio(struct property * prop)1465 static bool prop_is_gpio(struct property *prop)
1466 {
1467 char *str;
1468
1469 /*
1470 * *-gpios and *-gpio can appear in property names,
1471 * so skip over any false matches (only one known ATM)
1472 */
1473 if (strstr(prop->name, "nr-gpio"))
1474 return false;
1475
1476 str = strrchr(prop->name, '-');
1477 if (str)
1478 str++;
1479 else
1480 str = prop->name;
1481 if (!(streq(str, "gpios") || streq(str, "gpio")))
1482 return false;
1483
1484 return true;
1485 }
1486
check_gpios_property(struct check * c,struct dt_info * dti,struct node * node)1487 static void check_gpios_property(struct check *c,
1488 struct dt_info *dti,
1489 struct node *node)
1490 {
1491 struct property *prop;
1492
1493 /* Skip GPIO hog nodes which have 'gpios' property */
1494 if (get_property(node, "gpio-hog"))
1495 return;
1496
1497 for_each_property(node, prop) {
1498 struct provider provider;
1499
1500 if (!prop_is_gpio(prop))
1501 continue;
1502
1503 provider.prop_name = prop->name;
1504 provider.cell_name = "#gpio-cells";
1505 provider.optional = false;
1506 check_property_phandle_args(c, dti, node, prop, &provider);
1507 }
1508
1509 }
1510 WARNING(gpios_property, check_gpios_property, NULL, &phandle_references);
1511
check_deprecated_gpio_property(struct check * c,struct dt_info * dti,struct node * node)1512 static void check_deprecated_gpio_property(struct check *c,
1513 struct dt_info *dti,
1514 struct node *node)
1515 {
1516 struct property *prop;
1517
1518 for_each_property(node, prop) {
1519 char *str;
1520
1521 if (!prop_is_gpio(prop))
1522 continue;
1523
1524 str = strstr(prop->name, "gpio");
1525 if (!streq(str, "gpio"))
1526 continue;
1527
1528 FAIL_PROP(c, dti, node, prop,
1529 "'[*-]gpio' is deprecated, use '[*-]gpios' instead");
1530 }
1531
1532 }
1533 CHECK(deprecated_gpio_property, check_deprecated_gpio_property, NULL);
1534
node_is_interrupt_provider(struct node * node)1535 static bool node_is_interrupt_provider(struct node *node)
1536 {
1537 struct property *prop;
1538
1539 prop = get_property(node, "interrupt-controller");
1540 if (prop)
1541 return true;
1542
1543 prop = get_property(node, "interrupt-map");
1544 if (prop)
1545 return true;
1546
1547 return false;
1548 }
check_interrupts_property(struct check * c,struct dt_info * dti,struct node * node)1549 static void check_interrupts_property(struct check *c,
1550 struct dt_info *dti,
1551 struct node *node)
1552 {
1553 struct node *root = dti->dt;
1554 struct node *irq_node = NULL, *parent = node;
1555 struct property *irq_prop, *prop = NULL;
1556 int irq_cells, phandle;
1557
1558 irq_prop = get_property(node, "interrupts");
1559 if (!irq_prop)
1560 return;
1561
1562 if (irq_prop->val.len % sizeof(cell_t))
1563 FAIL_PROP(c, dti, node, irq_prop, "size (%d) is invalid, expected multiple of %zu",
1564 irq_prop->val.len, sizeof(cell_t));
1565
1566 while (parent && !prop) {
1567 if (parent != node && node_is_interrupt_provider(parent)) {
1568 irq_node = parent;
1569 break;
1570 }
1571
1572 prop = get_property(parent, "interrupt-parent");
1573 if (prop) {
1574 phandle = propval_cell(prop);
1575 if ((phandle == 0) || (phandle == -1)) {
1576 /* Give up if this is an overlay with
1577 * external references */
1578 if (dti->dtsflags & DTSF_PLUGIN)
1579 return;
1580 FAIL_PROP(c, dti, parent, prop, "Invalid phandle");
1581 continue;
1582 }
1583
1584 irq_node = get_node_by_phandle(root, phandle);
1585 if (!irq_node) {
1586 FAIL_PROP(c, dti, parent, prop, "Bad phandle");
1587 return;
1588 }
1589 if (!node_is_interrupt_provider(irq_node))
1590 FAIL(c, dti, irq_node,
1591 "Missing interrupt-controller or interrupt-map property");
1592
1593 break;
1594 }
1595
1596 parent = parent->parent;
1597 }
1598
1599 if (!irq_node) {
1600 FAIL(c, dti, node, "Missing interrupt-parent");
1601 return;
1602 }
1603
1604 prop = get_property(irq_node, "#interrupt-cells");
1605 if (!prop) {
1606 FAIL(c, dti, irq_node, "Missing #interrupt-cells in interrupt-parent");
1607 return;
1608 }
1609
1610 irq_cells = propval_cell(prop);
1611 if (irq_prop->val.len % (irq_cells * sizeof(cell_t))) {
1612 FAIL_PROP(c, dti, node, prop,
1613 "size is (%d), expected multiple of %d",
1614 irq_prop->val.len, (int)(irq_cells * sizeof(cell_t)));
1615 }
1616 }
1617 WARNING(interrupts_property, check_interrupts_property, &phandle_references);
1618
1619 static const struct bus_type graph_port_bus = {
1620 .name = "graph-port",
1621 };
1622
1623 static const struct bus_type graph_ports_bus = {
1624 .name = "graph-ports",
1625 };
1626
check_graph_nodes(struct check * c,struct dt_info * dti,struct node * node)1627 static void check_graph_nodes(struct check *c, struct dt_info *dti,
1628 struct node *node)
1629 {
1630 struct node *child;
1631
1632 for_each_child(node, child) {
1633 if (!(strprefixeq(child->name, child->basenamelen, "endpoint") ||
1634 get_property(child, "remote-endpoint")))
1635 continue;
1636
1637 node->bus = &graph_port_bus;
1638
1639 /* The parent of 'port' nodes can be either 'ports' or a device */
1640 if (!node->parent->bus &&
1641 (streq(node->parent->name, "ports") || get_property(node, "reg")))
1642 node->parent->bus = &graph_ports_bus;
1643
1644 break;
1645 }
1646
1647 }
1648 WARNING(graph_nodes, check_graph_nodes, NULL);
1649
check_graph_child_address(struct check * c,struct dt_info * dti,struct node * node)1650 static void check_graph_child_address(struct check *c, struct dt_info *dti,
1651 struct node *node)
1652 {
1653 int cnt = 0;
1654 struct node *child;
1655
1656 if (node->bus != &graph_ports_bus && node->bus != &graph_port_bus)
1657 return;
1658
1659 for_each_child(node, child) {
1660 struct property *prop = get_property(child, "reg");
1661
1662 /* No error if we have any non-zero unit address */
1663 if (prop && propval_cell(prop) != 0)
1664 return;
1665
1666 cnt++;
1667 }
1668
1669 if (cnt == 1 && node->addr_cells != -1)
1670 FAIL(c, dti, node, "graph node has single child node '%s', #address-cells/#size-cells are not necessary",
1671 node->children->name);
1672 }
1673 WARNING(graph_child_address, check_graph_child_address, NULL, &graph_nodes);
1674
check_graph_reg(struct check * c,struct dt_info * dti,struct node * node)1675 static void check_graph_reg(struct check *c, struct dt_info *dti,
1676 struct node *node)
1677 {
1678 char unit_addr[9];
1679 const char *unitname = get_unitname(node);
1680 struct property *prop;
1681
1682 prop = get_property(node, "reg");
1683 if (!prop || !unitname)
1684 return;
1685
1686 if (!(prop->val.val && prop->val.len == sizeof(cell_t))) {
1687 FAIL(c, dti, node, "graph node malformed 'reg' property");
1688 return;
1689 }
1690
1691 snprintf(unit_addr, sizeof(unit_addr), "%x", propval_cell(prop));
1692 if (!streq(unitname, unit_addr))
1693 FAIL(c, dti, node, "graph node unit address error, expected \"%s\"",
1694 unit_addr);
1695
1696 if (node->parent->addr_cells != 1)
1697 FAIL_PROP(c, dti, node, get_property(node, "#address-cells"),
1698 "graph node '#address-cells' is %d, must be 1",
1699 node->parent->addr_cells);
1700 if (node->parent->size_cells != 0)
1701 FAIL_PROP(c, dti, node, get_property(node, "#size-cells"),
1702 "graph node '#size-cells' is %d, must be 0",
1703 node->parent->size_cells);
1704 }
1705
check_graph_port(struct check * c,struct dt_info * dti,struct node * node)1706 static void check_graph_port(struct check *c, struct dt_info *dti,
1707 struct node *node)
1708 {
1709 if (node->bus != &graph_port_bus)
1710 return;
1711
1712 if (!strprefixeq(node->name, node->basenamelen, "port"))
1713 FAIL(c, dti, node, "graph port node name should be 'port'");
1714
1715 check_graph_reg(c, dti, node);
1716 }
1717 WARNING(graph_port, check_graph_port, NULL, &graph_nodes);
1718
get_remote_endpoint(struct check * c,struct dt_info * dti,struct node * endpoint)1719 static struct node *get_remote_endpoint(struct check *c, struct dt_info *dti,
1720 struct node *endpoint)
1721 {
1722 int phandle;
1723 struct node *node;
1724 struct property *prop;
1725
1726 prop = get_property(endpoint, "remote-endpoint");
1727 if (!prop)
1728 return NULL;
1729
1730 phandle = propval_cell(prop);
1731 /* Give up if this is an overlay with external references */
1732 if (phandle == 0 || phandle == -1)
1733 return NULL;
1734
1735 node = get_node_by_phandle(dti->dt, phandle);
1736 if (!node)
1737 FAIL_PROP(c, dti, endpoint, prop, "graph phandle is not valid");
1738
1739 return node;
1740 }
1741
check_graph_endpoint(struct check * c,struct dt_info * dti,struct node * node)1742 static void check_graph_endpoint(struct check *c, struct dt_info *dti,
1743 struct node *node)
1744 {
1745 struct node *remote_node;
1746
1747 if (!node->parent || node->parent->bus != &graph_port_bus)
1748 return;
1749
1750 if (!strprefixeq(node->name, node->basenamelen, "endpoint"))
1751 FAIL(c, dti, node, "graph endpoint node name should be 'endpoint'");
1752
1753 check_graph_reg(c, dti, node);
1754
1755 remote_node = get_remote_endpoint(c, dti, node);
1756 if (!remote_node)
1757 return;
1758
1759 if (get_remote_endpoint(c, dti, remote_node) != node)
1760 FAIL(c, dti, node, "graph connection to node '%s' is not bidirectional",
1761 remote_node->fullpath);
1762 }
1763 WARNING(graph_endpoint, check_graph_endpoint, NULL, &graph_nodes);
1764
1765 static struct check *check_table[] = {
1766 &duplicate_node_names, &duplicate_property_names,
1767 &node_name_chars, &node_name_format, &property_name_chars,
1768 &name_is_string, &name_properties,
1769
1770 &duplicate_label,
1771
1772 &explicit_phandles,
1773 &phandle_references, &path_references,
1774 &omit_unused_nodes,
1775
1776 &address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell,
1777 &device_type_is_string, &model_is_string, &status_is_string,
1778 &label_is_string,
1779
1780 &compatible_is_string_list, &names_is_string_list,
1781
1782 &property_name_chars_strict,
1783 &node_name_chars_strict,
1784
1785 &addr_size_cells, ®_format, &ranges_format,
1786
1787 &unit_address_vs_reg,
1788 &unit_address_format,
1789
1790 &pci_bridge,
1791 &pci_device_reg,
1792 &pci_device_bus_num,
1793
1794 &simple_bus_bridge,
1795 &simple_bus_reg,
1796
1797 &i2c_bus_bridge,
1798 &i2c_bus_reg,
1799
1800 &spi_bus_bridge,
1801 &spi_bus_reg,
1802
1803 &avoid_default_addr_size,
1804 &avoid_unnecessary_addr_size,
1805 &unique_unit_address,
1806 &unique_unit_address_if_enabled,
1807 &obsolete_chosen_interrupt_controller,
1808 &chosen_node_is_root, &chosen_node_bootargs, &chosen_node_stdout_path,
1809
1810 &clocks_property,
1811 &cooling_device_property,
1812 &dmas_property,
1813 &hwlocks_property,
1814 &interrupts_extended_property,
1815 &io_channels_property,
1816 &iommus_property,
1817 &mboxes_property,
1818 &msi_parent_property,
1819 &mux_controls_property,
1820 &phys_property,
1821 &power_domains_property,
1822 &pwms_property,
1823 &resets_property,
1824 &sound_dai_property,
1825 &thermal_sensors_property,
1826
1827 &deprecated_gpio_property,
1828 &gpios_property,
1829 &interrupts_property,
1830
1831 &alias_paths,
1832
1833 &graph_nodes, &graph_child_address, &graph_port, &graph_endpoint,
1834
1835 &always_fail,
1836 };
1837
enable_warning_error(struct check * c,bool warn,bool error)1838 static void enable_warning_error(struct check *c, bool warn, bool error)
1839 {
1840 int i;
1841
1842 /* Raising level, also raise it for prereqs */
1843 if ((warn && !c->warn) || (error && !c->error))
1844 for (i = 0; i < c->num_prereqs; i++)
1845 enable_warning_error(c->prereq[i], warn, error);
1846
1847 c->warn = c->warn || warn;
1848 c->error = c->error || error;
1849 }
1850
disable_warning_error(struct check * c,bool warn,bool error)1851 static void disable_warning_error(struct check *c, bool warn, bool error)
1852 {
1853 int i;
1854
1855 /* Lowering level, also lower it for things this is the prereq
1856 * for */
1857 if ((warn && c->warn) || (error && c->error)) {
1858 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
1859 struct check *cc = check_table[i];
1860 int j;
1861
1862 for (j = 0; j < cc->num_prereqs; j++)
1863 if (cc->prereq[j] == c)
1864 disable_warning_error(cc, warn, error);
1865 }
1866 }
1867
1868 c->warn = c->warn && !warn;
1869 c->error = c->error && !error;
1870 }
1871
parse_checks_option(bool warn,bool error,const char * arg)1872 void parse_checks_option(bool warn, bool error, const char *arg)
1873 {
1874 int i;
1875 const char *name = arg;
1876 bool enable = true;
1877
1878 if ((strncmp(arg, "no-", 3) == 0)
1879 || (strncmp(arg, "no_", 3) == 0)) {
1880 name = arg + 3;
1881 enable = false;
1882 }
1883
1884 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
1885 struct check *c = check_table[i];
1886
1887 if (streq(c->name, name)) {
1888 if (enable)
1889 enable_warning_error(c, warn, error);
1890 else
1891 disable_warning_error(c, warn, error);
1892 return;
1893 }
1894 }
1895
1896 die("Unrecognized check name \"%s\"\n", name);
1897 }
1898
process_checks(bool force,struct dt_info * dti)1899 void process_checks(bool force, struct dt_info *dti)
1900 {
1901 int i;
1902 int error = 0;
1903
1904 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
1905 struct check *c = check_table[i];
1906
1907 if (c->warn || c->error)
1908 error = error || run_check(c, dti);
1909 }
1910
1911 if (error) {
1912 if (!force) {
1913 fprintf(stderr, "ERROR: Input tree has errors, aborting "
1914 "(use -f to force output)\n");
1915 exit(2);
1916 } else if (quiet < 3) {
1917 fprintf(stderr, "Warning: Input tree has errors, "
1918 "output forced\n");
1919 }
1920 }
1921 }
1922