checks.c

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