lael-labs/linux

scripts/Makefile.lib+13−1

@@ -280,9 +280,21 @@ DTC ?= $(objtree)/scripts/dtc/dtc · 279 unmodified lines
280		280
281	# Disable noisy checks by default	281	# Disable noisy checks by default
282	ifeq ($(KBUILD_ENABLE_EXTRA_GCC_CHECKS),)	282	ifeq ($(KBUILD_ENABLE_EXTRA_GCC_CHECKS),)
283	DTC_FLAGS += -Wno-unit_address_vs_reg	283	DTC_FLAGS += -Wno-unit_address_vs_reg \
		284	-Wno-simple_bus_reg \
		285	-Wno-unit_address_format \
		286	-Wno-pci_bridge \
		287	-Wno-pci_device_bus_num \
		288	-Wno-pci_device_reg
284	endif	289	endif
285		290
		291	ifeq ($(KBUILD_ENABLE_EXTRA_GCC_CHECKS),2)
		292	DTC_FLAGS += -Wnode_name_chars_strict \
		293	-Wproperty_name_chars_strict
		294	endif
		295
		296	DTC_FLAGS += $(DTC_FLAGS_$(basetarget))
		297
286	# Generate an assembly file to wrap the output of the device tree compiler	298	# Generate an assembly file to wrap the output of the device tree compiler
287	quiet_cmd_dt_S_dtb= DTB $@	299	quiet_cmd_dt_S_dtb= DTB $@
288	cmd_dt_S_dtb= \	300	cmd_dt_S_dtb= \

scripts/dtc/checks.c+319−42

@@ -72,17 +72,16 @@ struct check { · 71 unmodified lines
72	#define CHECK(_nm, _fn, _d, ...) \	72	#define CHECK(_nm, _fn, _d, ...) \
73	CHECK_ENTRY(_nm, _fn, _d, false, false, __VA_ARGS__)	73	CHECK_ENTRY(_nm, _fn, _d, false, false, __VA_ARGS__)
74		74
75	#ifdef __GNUC__	75	static inline void PRINTF(3, 4) check_msg(struct check c, struct dt_info dti,
76	static inline void check_msg(struct check c, const char fmt, ...) __attribute__((format (printf, 2, 3)));	76	const char *fmt, ...)
77	#endif
78	static inline void check_msg(struct check c, const char fmt, ...)
79	{	77	{
80	va_list ap;	78	va_list ap;
81	va_start(ap, fmt);	79	va_start(ap, fmt);
82		80
83	if ((c->warn && (quiet < 1))	81	if ((c->warn && (quiet < 1))
84	\|\| (c->error && (quiet < 2))) {	82	\|\| (c->error && (quiet < 2))) {
85	fprintf(stderr, "%s (%s): ",	83	fprintf(stderr, "%s: %s (%s): ",
		84	strcmp(dti->outname, "-") ? dti->outname : "<stdout>",
86	(c->error) ? "ERROR" : "Warning", c->name);	85	(c->error) ? "ERROR" : "Warning", c->name);
87	vfprintf(stderr, fmt, ap);	86	vfprintf(stderr, fmt, ap);
88	fprintf(stderr, "\n");	87	fprintf(stderr, "\n");
@@ -90,11 +89,11 @@ static inline void check_msg(struct check c, const char fmt, ...) · 1 unmodified line
90	va_end(ap);	89	va_end(ap);
91	}	90	}
92		91
93	#define FAIL(c, ...) \	92	#define FAIL(c, dti, ...) \
94	do { \	93	do { \
95	TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \	94	TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
96	(c)->status = FAILED; \	95	(c)->status = FAILED; \
97	check_msg((c), __VA_ARGS__); \	96	check_msg((c), dti, __VA_ARGS__); \
98	} while (0)	97	} while (0)
99		98
100	static void check_nodes_props(struct check c, struct dt_info dti, struct node *node)	99	static void check_nodes_props(struct check c, struct dt_info dti, struct node *node)
@@ -127,7 +126,7 @@ static bool run_check(struct check c, struct dt_info dti) · 26 unmodified lines
127	error = error \|\| run_check(prq, dti);	126	error = error \|\| run_check(prq, dti);
128	if (prq->status != PASSED) {	127	if (prq->status != PASSED) {
129	c->status = PREREQ;	128	c->status = PREREQ;
130	check_msg(c, "Failed prerequisite '%s'",	129	check_msg(c, dti, "Failed prerequisite '%s'",
131	c->prereq[i]->name);	130	c->prereq[i]->name);
132	}	131	}
133	}	132	}
@@ -157,7 +156,7 @@ out: · 23 unmodified lines
157	static inline void check_always_fail(struct check c, struct dt_info dti,	156	static inline void check_always_fail(struct check c, struct dt_info dti,
158	struct node *node)	157	struct node *node)
159	{	158	{
160	FAIL(c, "always_fail check");	159	FAIL(c, dti, "always_fail check");
161	}	160	}
162	CHECK(always_fail, check_always_fail, NULL);	161	CHECK(always_fail, check_always_fail, NULL);
163		162
@@ -172,7 +171,7 @@ static void check_is_string(struct check c, struct dt_info dti, · 8 unmodified lines
172	return; /* Not present, assumed ok */	171	return; /* Not present, assumed ok */
173		172
174	if (!data_is_one_string(prop->val))	173	if (!data_is_one_string(prop->val))
175	FAIL(c, "\"%s\" property in %s is not a string",	174	FAIL(c, dti, "\"%s\" property in %s is not a string",
176	propname, node->fullpath);	175	propname, node->fullpath);
177	}	176	}
178	#define WARNING_IF_NOT_STRING(nm, propname) \	177	#define WARNING_IF_NOT_STRING(nm, propname) \
@@ -191,7 +190,7 @@ static void check_is_cell(struct check c, struct dt_info dti, · 12 unmodified lines
191	return; /* Not present, assumed ok */	190	return; /* Not present, assumed ok */
192		191
193	if (prop->val.len != sizeof(cell_t))	192	if (prop->val.len != sizeof(cell_t))
194	FAIL(c, "\"%s\" property in %s is not a single cell",	193	FAIL(c, dti, "\"%s\" property in %s is not a single cell",
195	propname, node->fullpath);	194	propname, node->fullpath);
196	}	195	}
197	#define WARNING_IF_NOT_CELL(nm, propname) \	196	#define WARNING_IF_NOT_CELL(nm, propname) \
@@ -213,7 +212,7 @@ static void check_duplicate_node_names(struct check c, struct dt_info dti, · 15 unmodified lines
213	child2;	212	child2;
214	child2 = child2->next_sibling)	213	child2 = child2->next_sibling)
215	if (streq(child->name, child2->name))	214	if (streq(child->name, child2->name))
216	FAIL(c, "Duplicate node name %s",	215	FAIL(c, dti, "Duplicate node name %s",
217	child->fullpath);	216	child->fullpath);
218	}	217	}
219	ERROR(duplicate_node_names, check_duplicate_node_names, NULL);	218	ERROR(duplicate_node_names, check_duplicate_node_names, NULL);
@@ -228,7 +227,7 @@ static void check_duplicate_property_names(struct check c, struct dt_info dti, · 8 unmodified lines
228	if (prop2->deleted)	227	if (prop2->deleted)
229	continue;	228	continue;
230	if (streq(prop->name, prop2->name))	229	if (streq(prop->name, prop2->name))
231	FAIL(c, "Duplicate property name %s in %s",	230	FAIL(c, dti, "Duplicate property name %s in %s",
232	prop->name, node->fullpath);	231	prop->name, node->fullpath);
233	}	232	}
234	}	233	}
@@ -239,6 +238,7 @@ ERROR(duplicate_property_names, check_duplicate_property_names, NULL); · 4 unmodified lines
239	#define UPPERCASE "ABCDEFGHIJKLMNOPQRSTUVWXYZ"	238	#define UPPERCASE "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
240	#define DIGITS "0123456789"	239	#define DIGITS "0123456789"
241	#define PROPNODECHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-"	240	#define PROPNODECHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-"
		241	#define PROPNODECHARSSTRICT LOWERCASE UPPERCASE DIGITS ",-"
242		242
243	static void check_node_name_chars(struct check c, struct dt_info dti,	243	static void check_node_name_chars(struct check c, struct dt_info dti,
244	struct node *node)	244	struct node *node)
@@ -246,16 +246,27 @@ static void check_node_name_chars(struct check c, struct dt_info dti, · 1 unmodified line
246	int n = strspn(node->name, c->data);	246	int n = strspn(node->name, c->data);
247		247
248	if (n < strlen(node->name))	248	if (n < strlen(node->name))
249	FAIL(c, "Bad character '%c' in node %s",	249	FAIL(c, dti, "Bad character '%c' in node %s",
250	node->name[n], node->fullpath);	250	node->name[n], node->fullpath);
251	}	251	}
252	ERROR(node_name_chars, check_node_name_chars, PROPNODECHARS "@");	252	ERROR(node_name_chars, check_node_name_chars, PROPNODECHARS "@");
253		253
		254	static void check_node_name_chars_strict(struct check c, struct dt_info dti,
		255	struct node *node)
		256	{
		257	int n = strspn(node->name, c->data);
		258
		259	if (n < node->basenamelen)
		260	FAIL(c, dti, "Character '%c' not recommended in node %s",
		261	node->name[n], node->fullpath);
		262	}
		263	CHECK(node_name_chars_strict, check_node_name_chars_strict, PROPNODECHARSSTRICT);
		264
254	static void check_node_name_format(struct check c, struct dt_info dti,	265	static void check_node_name_format(struct check c, struct dt_info dti,
255	struct node *node)	266	struct node *node)
256	{	267	{
257	if (strchr(get_unitname(node), '@'))	268	if (strchr(get_unitname(node), '@'))
258	FAIL(c, "Node %s has multiple '@' characters in name",	269	FAIL(c, dti, "Node %s has multiple '@' characters in name",
259	node->fullpath);	270	node->fullpath);
260	}	271	}
261	ERROR(node_name_format, check_node_name_format, NULL, &node_name_chars);	272	ERROR(node_name_format, check_node_name_format, NULL, &node_name_chars);
@@ -274,11 +285,11 @@ static void check_unit_address_vs_reg(struct check c, struct dt_info dti, · 12 unmodified lines
274		285
275	if (prop) {	286	if (prop) {
276	if (!unitname[0])	287	if (!unitname[0])
277	FAIL(c, "Node %s has a reg or ranges property, but no unit name",	288	FAIL(c, dti, "Node %s has a reg or ranges property, but no unit name",
278	node->fullpath);	289	node->fullpath);
279	} else {	290	} else {
280	if (unitname[0])	291	if (unitname[0])
281	FAIL(c, "Node %s has a unit name, but no reg property",	292	FAIL(c, dti, "Node %s has a unit name, but no reg property",
282	node->fullpath);	293	node->fullpath);
283	}	294	}
284	}	295	}
@@ -293,12 +304,44 @@ static void check_property_name_chars(struct check c, struct dt_info dti, · 8 unmodified lines
293	int n = strspn(prop->name, c->data);	304	int n = strspn(prop->name, c->data);
294		305
295	if (n < strlen(prop->name))	306	if (n < strlen(prop->name))
296	FAIL(c, "Bad character '%c' in property name \"%s\", node %s",	307	FAIL(c, dti, "Bad character '%c' in property name \"%s\", node %s",
297	prop->name[n], prop->name, node->fullpath);	308	prop->name[n], prop->name, node->fullpath);
298	}	309	}
299	}	310	}
300	ERROR(property_name_chars, check_property_name_chars, PROPNODECHARS);	311	ERROR(property_name_chars, check_property_name_chars, PROPNODECHARS);
301		312
		313	static void check_property_name_chars_strict(struct check *c,
		314	struct dt_info *dti,
		315	struct node *node)
		316	{
		317	struct property *prop;
		318
		319	for_each_property(node, prop) {
		320	const char *name = prop->name;
		321	int n = strspn(name, c->data);
		322
		323	if (n == strlen(prop->name))
		324	continue;
		325
		326	/* Certain names are whitelisted */
		327	if (streq(name, "device_type"))
		328	continue;
		329
		330	/*
		331	* # is only allowed at the beginning of property names not counting
		332	* the vendor prefix.
		333	*/
		334	if (name[n] == '#' && ((n == 0) \|\| (name[n-1] == ','))) {
		335	name += n + 1;
		336	n = strspn(name, c->data);
		337	}
		338	if (n < strlen(name))
		339	FAIL(c, dti, "Character '%c' not recommended in property name \"%s\", node %s",
		340	name[n], prop->name, node->fullpath);
		341	}
		342	}
		343	CHECK(property_name_chars_strict, check_property_name_chars_strict, PROPNODECHARSSTRICT);
		344
302	#define DESCLABEL_FMT "%s%s%s%s%s"	345	#define DESCLABEL_FMT "%s%s%s%s%s"
303	#define DESCLABEL_ARGS(node,prop,mark) \	346	#define DESCLABEL_ARGS(node,prop,mark) \
304	((mark) ? "value of " : ""), \	347	((mark) ? "value of " : ""), \
@@ -327,7 +370,7 @@ static void check_duplicate_label(struct check c, struct dt_info dti, · 22 unmodified lines
327	return;	370	return;
328		371
329	if ((othernode != node) \|\| (otherprop != prop) \|\| (othermark != mark))	372	if ((othernode != node) \|\| (otherprop != prop) \|\| (othermark != mark))
330	FAIL(c, "Duplicate label '%s' on " DESCLABEL_FMT	373	FAIL(c, dti, "Duplicate label '%s' on " DESCLABEL_FMT
331	" and " DESCLABEL_FMT,	374	" and " DESCLABEL_FMT,
332	label, DESCLABEL_ARGS(node, prop, mark),	375	label, DESCLABEL_ARGS(node, prop, mark),
333	DESCLABEL_ARGS(othernode, otherprop, othermark));	376	DESCLABEL_ARGS(othernode, otherprop, othermark));
@@ -367,7 +410,7 @@ static cell_t check_phandle_prop(struct check c, struct dt_info dti, · 33 unmodified lines
367	return 0;	410	return 0;
368		411
369	if (prop->val.len != sizeof(cell_t)) {	412	if (prop->val.len != sizeof(cell_t)) {
370	FAIL(c, "%s has bad length (%d) %s property",	413	FAIL(c, dti, "%s has bad length (%d) %s property",
371	node->fullpath, prop->val.len, prop->name);	414	node->fullpath, prop->val.len, prop->name);
372	return 0;	415	return 0;
373	}	416	}
@@ -379,7 +422,7 @@ static cell_t check_phandle_prop(struct check c, struct dt_info dti, · 5 unmodified lines
379	/* "Set this node's phandle equal to some	422	/* "Set this node's phandle equal to some
380	* other node's phandle". That's nonsensical	423	* other node's phandle". That's nonsensical
381	* by construction. */ {	424	* by construction. */ {
382	FAIL(c, "%s in %s is a reference to another node",	425	FAIL(c, dti, "%s in %s is a reference to another node",
383	prop->name, node->fullpath);	426	prop->name, node->fullpath);
384	}	427	}
385	/* But setting this node's phandle equal to its own	428	/* But setting this node's phandle equal to its own
@@ -393,7 +436,7 @@ static cell_t check_phandle_prop(struct check c, struct dt_info dti, · 7 unmodified lines
393	phandle = propval_cell(prop);	436	phandle = propval_cell(prop);
394		437
395	if ((phandle == 0) \|\| (phandle == -1)) {	438	if ((phandle == 0) \|\| (phandle == -1)) {
396	FAIL(c, "%s has bad value (0x%x) in %s property",	439	FAIL(c, dti, "%s has bad value (0x%x) in %s property",
397	node->fullpath, phandle, prop->name);	440	node->fullpath, phandle, prop->name);
398	return 0;	441	return 0;
399	}	442	}
@@ -420,7 +463,7 @@ static void check_explicit_phandles(struct check c, struct dt_info dti, · 20 unmodified lines
420	return;	463	return;
421		464
422	if (linux_phandle && phandle && (phandle != linux_phandle))	465	if (linux_phandle && phandle && (phandle != linux_phandle))
423	FAIL(c, "%s has mismatching 'phandle' and 'linux,phandle'"	466	FAIL(c, dti, "%s has mismatching 'phandle' and 'linux,phandle'"
424	" properties", node->fullpath);	467	" properties", node->fullpath);
425		468
426	if (linux_phandle && !phandle)	469	if (linux_phandle && !phandle)
@@ -428,7 +471,7 @@ static void check_explicit_phandles(struct check c, struct dt_info dti, · 1 unmodified line
428		471
429	other = get_node_by_phandle(root, phandle);	472	other = get_node_by_phandle(root, phandle);
430	if (other && (other != node)) {	473	if (other && (other != node)) {
431	FAIL(c, "%s has duplicated phandle 0x%x (seen before at %s)",	474	FAIL(c, dti, "%s has duplicated phandle 0x%x (seen before at %s)",
432	node->fullpath, phandle, other->fullpath);	475	node->fullpath, phandle, other->fullpath);
433	return;	476	return;
434	}	477	}
@@ -453,7 +496,7 @@ static void check_name_properties(struct check c, struct dt_info dti, · 18 unmodified lines
453		496
454	if ((prop->val.len != node->basenamelen+1)	497	if ((prop->val.len != node->basenamelen+1)
455	\|\| (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {	498	\|\| (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
456	FAIL(c, "\"name\" property in %s is incorrect (\"%s\" instead"	499	FAIL(c, dti, "\"name\" property in %s is incorrect (\"%s\" instead"
457	" of base node name)", node->fullpath, prop->val.val);	500	" of base node name)", node->fullpath, prop->val.val);
458	} else {	501	} else {
459	/* The name property is correct, and therefore redundant.	502	/* The name property is correct, and therefore redundant.
@@ -488,16 +531,16 @@ static void fixup_phandle_references(struct check c, struct dt_info dti, · 28 unmodified lines
488	refnode = get_node_by_ref(dt, m->ref);	531	refnode = get_node_by_ref(dt, m->ref);
489	if (! refnode) {	532	if (! refnode) {
490	if (!(dti->dtsflags & DTSF_PLUGIN))	533	if (!(dti->dtsflags & DTSF_PLUGIN))
491	FAIL(c, "Reference to non-existent node or "	534	FAIL(c, dti, "Reference to non-existent node or "
492	"label \"%s\"\n", m->ref);	535	"label \"%s\"\n", m->ref);
493	else /* mark the entry as unresolved */	536	else /* mark the entry as unresolved */
494	((cell_t )(prop->val.val + m->offset)) =	537	((fdt32_t )(prop->val.val + m->offset)) =
495	cpu_to_fdt32(0xffffffff);	538	cpu_to_fdt32(0xffffffff);
496	continue;	539	continue;
497	}	540	}
498		541
499	phandle = get_node_phandle(dt, refnode);	542	phandle = get_node_phandle(dt, refnode);
500	((cell_t )(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);	543	((fdt32_t )(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
501	}	544	}
502	}	545	}
503	}	546	}
@@ -520,7 +563,7 @@ static void fixup_path_references(struct check c, struct dt_info dti, · 16 unmodified lines
520		563
521	refnode = get_node_by_ref(dt, m->ref);	564	refnode = get_node_by_ref(dt, m->ref);
522	if (!refnode) {	565	if (!refnode) {
523	FAIL(c, "Reference to non-existent node or label \"%s\"\n",	566	FAIL(c, dti, "Reference to non-existent node or label \"%s\"\n",
524	m->ref);	567	m->ref);
525	continue;	568	continue;
526	}	569	}
@@ -579,19 +622,19 @@ static void check_reg_format(struct check c, struct dt_info dti, · 52 unmodified lines
579	return; /* No "reg", that's fine */	622	return; /* No "reg", that's fine */
580		623
581	if (!node->parent) {	624	if (!node->parent) {
582	FAIL(c, "Root node has a \"reg\" property");	625	FAIL(c, dti, "Root node has a \"reg\" property");
583	return;	626	return;
584	}	627	}
585		628
586	if (prop->val.len == 0)	629	if (prop->val.len == 0)
587	FAIL(c, "\"reg\" property in %s is empty", node->fullpath);	630	FAIL(c, dti, "\"reg\" property in %s is empty", node->fullpath);
588		631
589	addr_cells = node_addr_cells(node->parent);	632	addr_cells = node_addr_cells(node->parent);
590	size_cells = node_size_cells(node->parent);	633	size_cells = node_size_cells(node->parent);
591	entrylen = (addr_cells + size_cells) * sizeof(cell_t);	634	entrylen = (addr_cells + size_cells) * sizeof(cell_t);
592		635
593	if (!entrylen \|\| (prop->val.len % entrylen) != 0)	636	if (!entrylen \|\| (prop->val.len % entrylen) != 0)
594	FAIL(c, "\"reg\" property in %s has invalid length (%d bytes) "	637	FAIL(c, dti, "\"reg\" property in %s has invalid length (%d bytes) "
595	"(#address-cells == %d, #size-cells == %d)",	638	"(#address-cells == %d, #size-cells == %d)",
596	node->fullpath, prop->val.len, addr_cells, size_cells);	639	node->fullpath, prop->val.len, addr_cells, size_cells);
597	}	640	}
@@ -608,7 +651,7 @@ static void check_ranges_format(struct check c, struct dt_info dti, · 10 unmodified lines
608	return;	651	return;
609		652
610	if (!node->parent) {	653	if (!node->parent) {
611	FAIL(c, "Root node has a \"ranges\" property");	654	FAIL(c, dti, "Root node has a \"ranges\" property");
612	return;	655	return;
613	}	656	}
614		657
@@ -620,17 +663,17 @@ static void check_ranges_format(struct check c, struct dt_info dti, · 5 unmodified lines
620		663
621	if (prop->val.len == 0) {	664	if (prop->val.len == 0) {
622	if (p_addr_cells != c_addr_cells)	665	if (p_addr_cells != c_addr_cells)
623	FAIL(c, "%s has empty \"ranges\" property but its "	666	FAIL(c, dti, "%s has empty \"ranges\" property but its "
624	"#address-cells (%d) differs from %s (%d)",	667	"#address-cells (%d) differs from %s (%d)",
625	node->fullpath, c_addr_cells, node->parent->fullpath,	668	node->fullpath, c_addr_cells, node->parent->fullpath,
626	p_addr_cells);	669	p_addr_cells);
627	if (p_size_cells != c_size_cells)	670	if (p_size_cells != c_size_cells)
628	FAIL(c, "%s has empty \"ranges\" property but its "	671	FAIL(c, dti, "%s has empty \"ranges\" property but its "
629	"#size-cells (%d) differs from %s (%d)",	672	"#size-cells (%d) differs from %s (%d)",
630	node->fullpath, c_size_cells, node->parent->fullpath,	673	node->fullpath, c_size_cells, node->parent->fullpath,
631	p_size_cells);	674	p_size_cells);
632	} else if ((prop->val.len % entrylen) != 0) {	675	} else if ((prop->val.len % entrylen) != 0) {
633	FAIL(c, "\"ranges\" property in %s has invalid length (%d bytes) "	676	FAIL(c, dti, "\"ranges\" property in %s has invalid length (%d bytes) "
634	"(parent #address-cells == %d, child #address-cells == %d, "	677	"(parent #address-cells == %d, child #address-cells == %d, "
635	"#size-cells == %d)", node->fullpath, prop->val.len,	678	"#size-cells == %d)", node->fullpath, prop->val.len,
636	p_addr_cells, c_addr_cells, c_size_cells);	679	p_addr_cells, c_addr_cells, c_size_cells);
@@ -638,6 +681,229 @@ static void check_ranges_format(struct check c, struct dt_info dti, · 1 unmodified line
638	}	681	}
639	WARNING(ranges_format, check_ranges_format, NULL, &addr_size_cells);	682	WARNING(ranges_format, check_ranges_format, NULL, &addr_size_cells);
640		683
		684	static const struct bus_type pci_bus = {
		685	.name = "PCI",
		686	};
		687
		688	static void check_pci_bridge(struct check c, struct dt_info dti, struct node *node)
		689	{
		690	struct property *prop;
		691	cell_t *cells;
		692
		693	prop = get_property(node, "device_type");
		694	if (!prop \|\| !streq(prop->val.val, "pci"))
		695	return;
		696
		697	node->bus = &pci_bus;
		698
		699	if (!strneq(node->name, "pci", node->basenamelen) &&
		700	!strneq(node->name, "pcie", node->basenamelen))
		701	FAIL(c, dti, "Node %s node name is not \"pci\" or \"pcie\"",
		702	node->fullpath);
		703
		704	prop = get_property(node, "ranges");
		705	if (!prop)
		706	FAIL(c, dti, "Node %s missing ranges for PCI bridge (or not a bridge)",
		707	node->fullpath);
		708
		709	if (node_addr_cells(node) != 3)
		710	FAIL(c, dti, "Node %s incorrect #address-cells for PCI bridge",
		711	node->fullpath);
		712	if (node_size_cells(node) != 2)
		713	FAIL(c, dti, "Node %s incorrect #size-cells for PCI bridge",
		714	node->fullpath);
		715
		716	prop = get_property(node, "bus-range");
		717	if (!prop) {
		718	FAIL(c, dti, "Node %s missing bus-range for PCI bridge",
		719	node->fullpath);
		720	return;
		721	}
		722	if (prop->val.len != (sizeof(cell_t) * 2)) {
		723	FAIL(c, dti, "Node %s bus-range must be 2 cells",
		724	node->fullpath);
		725	return;
		726	}
		727	cells = (cell_t *)prop->val.val;
		728	if (fdt32_to_cpu(cells[0]) > fdt32_to_cpu(cells[1]))
		729	FAIL(c, dti, "Node %s bus-range 1st cell must be less than or equal to 2nd cell",
		730	node->fullpath);
		731	if (fdt32_to_cpu(cells[1]) > 0xff)
		732	FAIL(c, dti, "Node %s bus-range maximum bus number must be less than 256",
		733	node->fullpath);
		734	}
		735	WARNING(pci_bridge, check_pci_bridge, NULL,
		736	&device_type_is_string, &addr_size_cells);
		737
		738	static void check_pci_device_bus_num(struct check c, struct dt_info dti, struct node *node)
		739	{
		740	struct property *prop;
		741	unsigned int bus_num, min_bus, max_bus;
		742	cell_t *cells;
		743
		744	if (!node->parent \|\| (node->parent->bus != &pci_bus))
		745	return;
		746
		747	prop = get_property(node, "reg");
		748	if (!prop)
		749	return;
		750
		751	cells = (cell_t *)prop->val.val;
		752	bus_num = (fdt32_to_cpu(cells[0]) & 0x00ff0000) >> 16;
		753
		754	prop = get_property(node->parent, "bus-range");
		755	if (!prop) {
		756	min_bus = max_bus = 0;
		757	} else {
		758	cells = (cell_t *)prop->val.val;
		759	min_bus = fdt32_to_cpu(cells[0]);
		760	max_bus = fdt32_to_cpu(cells[0]);
		761	}
		762	if ((bus_num < min_bus) \|\| (bus_num > max_bus))
		763	FAIL(c, dti, "Node %s PCI bus number %d out of range, expected (%d - %d)",
		764	node->fullpath, bus_num, min_bus, max_bus);
		765	}
		766	WARNING(pci_device_bus_num, check_pci_device_bus_num, NULL, &reg_format, &pci_bridge);
		767
		768	static void check_pci_device_reg(struct check c, struct dt_info dti, struct node *node)
		769	{
		770	struct property *prop;
		771	const char *unitname = get_unitname(node);
		772	char unit_addr[5];
		773	unsigned int dev, func, reg;
		774	cell_t *cells;
		775
		776	if (!node->parent \|\| (node->parent->bus != &pci_bus))
		777	return;
		778
		779	prop = get_property(node, "reg");
		780	if (!prop) {
		781	FAIL(c, dti, "Node %s missing PCI reg property", node->fullpath);
		782	return;
		783	}
		784
		785	cells = (cell_t *)prop->val.val;
		786	if (cells[1] \|\| cells[2])
		787	FAIL(c, dti, "Node %s PCI reg config space address cells 2 and 3 must be 0",
		788	node->fullpath);
		789
		790	reg = fdt32_to_cpu(cells[0]);
		791	dev = (reg & 0xf800) >> 11;
		792	func = (reg & 0x700) >> 8;
		793
		794	if (reg & 0xff000000)
		795	FAIL(c, dti, "Node %s PCI reg address is not configuration space",
		796	node->fullpath);
		797	if (reg & 0x000000ff)
		798	FAIL(c, dti, "Node %s PCI reg config space address register number must be 0",
		799	node->fullpath);
		800
		801	if (func == 0) {
		802	snprintf(unit_addr, sizeof(unit_addr), "%x", dev);
		803	if (streq(unitname, unit_addr))
		804	return;
		805	}
		806
		807	snprintf(unit_addr, sizeof(unit_addr), "%x,%x", dev, func);
		808	if (streq(unitname, unit_addr))
		809	return;
		810
		811	FAIL(c, dti, "Node %s PCI unit address format error, expected \"%s\"",
		812	node->fullpath, unit_addr);
		813	}
		814	WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format, &pci_bridge);
		815
		816	static const struct bus_type simple_bus = {
		817	.name = "simple-bus",
		818	};
		819
		820	static bool node_is_compatible(struct node node, const char compat)
		821	{
		822	struct property *prop;
		823	const char str, end;
		824
		825	prop = get_property(node, "compatible");
		826	if (!prop)
		827	return false;
		828
		829	for (str = prop->val.val, end = str + prop->val.len; str < end;
		830	str += strnlen(str, end - str) + 1) {
		831	if (strneq(str, compat, end - str))
		832	return true;
		833	}
		834	return false;
		835	}
		836
		837	static void check_simple_bus_bridge(struct check c, struct dt_info dti, struct node *node)
		838	{
		839	if (node_is_compatible(node, "simple-bus"))
		840	node->bus = &simple_bus;
		841	}
		842	WARNING(simple_bus_bridge, check_simple_bus_bridge, NULL, &addr_size_cells);
		843
		844	static void check_simple_bus_reg(struct check c, struct dt_info dti, struct node *node)
		845	{
		846	struct property *prop;
		847	const char *unitname = get_unitname(node);
		848	char unit_addr[17];
		849	unsigned int size;
		850	uint64_t reg = 0;
		851	cell_t *cells = NULL;
		852
		853	if (!node->parent \|\| (node->parent->bus != &simple_bus))
		854	return;
		855
		856	prop = get_property(node, "reg");
		857	if (prop)
		858	cells = (cell_t *)prop->val.val;
		859	else {
		860	prop = get_property(node, "ranges");
		861	if (prop && prop->val.len)
		862	/* skip of child address */
		863	cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
		864	}
		865
		866	if (!cells) {
		867	if (node->parent->parent && !(node->bus == &simple_bus))
		868	FAIL(c, dti, "Node %s missing or empty reg/ranges property", node->fullpath);
		869	return;
		870	}
		871
		872	size = node_addr_cells(node->parent);
		873	while (size--)
		874	reg = (reg << 32) \| fdt32_to_cpu(*(cells++));
		875
		876	snprintf(unit_addr, sizeof(unit_addr), "%lx", reg);
		877	if (!streq(unitname, unit_addr))
		878	FAIL(c, dti, "Node %s simple-bus unit address format error, expected \"%s\"",
		879	node->fullpath, unit_addr);
		880	}
		881	WARNING(simple_bus_reg, check_simple_bus_reg, NULL, &reg_format, &simple_bus_bridge);
		882
		883	static void check_unit_address_format(struct check c, struct dt_info dti,
		884	struct node *node)
		885	{
		886	const char *unitname = get_unitname(node);
		887
		888	if (node->parent && node->parent->bus)
		889	return;
		890
		891	if (!unitname[0])
		892	return;
		893
		894	if (!strncmp(unitname, "0x", 2)) {
		895	FAIL(c, dti, "Node %s unit name should not have leading \"0x\"",
		896	node->fullpath);
		897	/* skip over 0x for next test */
		898	unitname += 2;
		899	}
		900	if (unitname[0] == '0' && isxdigit(unitname[1]))
		901	FAIL(c, dti, "Node %s unit name should not have leading 0s",
		902	node->fullpath);
		903	}
		904	WARNING(unit_address_format, check_unit_address_format, NULL,
		905	&node_name_format, &pci_bridge, &simple_bus_bridge);
		906
641	/*	907	/*
642	* Style checks	908	* Style checks
643	*/	909	*/
@@ -656,11 +922,11 @@ static void check_avoid_default_addr_size(struct check c, struct dt_info dti, · 12 unmodified lines
656	return;	922	return;
657		923
658	if (node->parent->addr_cells == -1)	924	if (node->parent->addr_cells == -1)
659	FAIL(c, "Relying on default #address-cells value for %s",	925	FAIL(c, dti, "Relying on default #address-cells value for %s",
660	node->fullpath);	926	node->fullpath);
661		927
662	if (node->parent->size_cells == -1)	928	if (node->parent->size_cells == -1)
663	FAIL(c, "Relying on default #size-cells value for %s",	929	FAIL(c, dti, "Relying on default #size-cells value for %s",
664	node->fullpath);	930	node->fullpath);
665	}	931	}
666	WARNING(avoid_default_addr_size, check_avoid_default_addr_size, NULL,	932	WARNING(avoid_default_addr_size, check_avoid_default_addr_size, NULL,
@@ -684,7 +950,7 @@ static void check_obsolete_chosen_interrupt_controller(struct check *c, · 17 unmodified lines
684		950
685	prop = get_property(chosen, "interrupt-controller");	951	prop = get_property(chosen, "interrupt-controller");
686	if (prop)	952	if (prop)
687	FAIL(c, "/chosen has obsolete \"interrupt-controller\" "	953	FAIL(c, dti, "/chosen has obsolete \"interrupt-controller\" "
688	"property");	954	"property");
689	}	955	}
690	WARNING(obsolete_chosen_interrupt_controller,	956	WARNING(obsolete_chosen_interrupt_controller,
@@ -703,9 +969,20 @@ static struct check *check_table[] = { · 12 unmodified lines
703	&address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell,	969	&address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell,
704	&device_type_is_string, &model_is_string, &status_is_string,	970	&device_type_is_string, &model_is_string, &status_is_string,
705		971
		972	&property_name_chars_strict,
		973	&node_name_chars_strict,
		974
706	&addr_size_cells, &reg_format, &ranges_format,	975	&addr_size_cells, &reg_format, &ranges_format,
707		976
708	&unit_address_vs_reg,	977	&unit_address_vs_reg,
		978	&unit_address_format,
		979
		980	&pci_bridge,
		981	&pci_device_reg,
		982	&pci_device_bus_num,
		983
		984	&simple_bus_bridge,
		985	&simple_bus_reg,
709		986
710	&avoid_default_addr_size,	987	&avoid_default_addr_size,
711	&obsolete_chosen_interrupt_controller,	988	&obsolete_chosen_interrupt_controller,

scripts/dtc/data.c+8−8

@@ -171,9 +171,9 @@ struct data data_merge(struct data d1, struct data d2) · 170 unmodified lines
171	struct data data_append_integer(struct data d, uint64_t value, int bits)	171	struct data data_append_integer(struct data d, uint64_t value, int bits)
172	{	172	{
173	uint8_t value_8;	173	uint8_t value_8;
174	uint16_t value_16;	174	fdt16_t value_16;
175	uint32_t value_32;	175	fdt32_t value_32;
176	uint64_t value_64;	176	fdt64_t value_64;
177		177
178	switch (bits) {	178	switch (bits) {
179	case 8:	179	case 8:
@@ -197,14 +197,14 @@ struct data data_append_integer(struct data d, uint64_t value, int bits) · 17 unmodified lines
197	}	197	}
198	}	198	}
199		199
200	struct data data_append_re(struct data d, const struct fdt_reserve_entry *re)	200	struct data data_append_re(struct data d, uint64_t address, uint64_t size)
201	{	201	{
202	struct fdt_reserve_entry bere;	202	struct fdt_reserve_entry re;
203		203
204	bere.address = cpu_to_fdt64(re->address);	204	re.address = cpu_to_fdt64(address);
205	bere.size = cpu_to_fdt64(re->size);	205	re.size = cpu_to_fdt64(size);
206		206
207	return data_append_data(d, &bere, sizeof(bere));	207	return data_append_data(d, &re, sizeof(re));
208	}	208	}
209		209
210	struct data data_append_cell(struct data d, cell_t word)	210	struct data data_append_cell(struct data d, cell_t word)

scripts/dtc/dtc-lexer.l+2−1

@@ -62,7 +62,8 @@ static int dts_version = 1; · 61 unmodified lines
62		62
63	static void push_input_file(const char *filename);	63	static void push_input_file(const char *filename);
64	static bool pop_input_file(void);	64	static bool pop_input_file(void);
65	static void lexical_error(const char *fmt, ...);	65	static void PRINTF(1, 2) lexical_error(const char *fmt, ...);
		66
66	%}	67	%}
67		68
68	%%	69	%%

scripts/dtc/dtc-lexer.lex.c_shipped+39−38

@@ -655,8 +655,9 @@ static int dts_version = 1; · 654 unmodified lines
655		655
656	static void push_input_file(const char *filename);	656	static void push_input_file(const char *filename);
657	static bool pop_input_file(void);	657	static bool pop_input_file(void);
658	static void lexical_error(const char *fmt, ...);	658	static void PRINTF(1, 2) lexical_error(const char *fmt, ...);
659	#line 660 "dtc-lexer.lex.c"	659
		660	#line 661 "dtc-lexer.lex.c"
660		661
661	#define INITIAL 0	662	#define INITIAL 0
662	#define BYTESTRING 1	663	#define BYTESTRING 1
@@ -878,9 +879,9 @@ YY_DECL · 215 unmodified lines
878	}	879	}
879		880
880	{	881	{
881	#line 68 "dtc-lexer.l"	882	#line 69 "dtc-lexer.l"
882		883
883	#line 884 "dtc-lexer.lex.c"	884	#line 885 "dtc-lexer.lex.c"
884		885
885	while ( /CONSTCOND/1 ) /* loops until end-of-file is reached */	886	while ( /CONSTCOND/1 ) /* loops until end-of-file is reached */
886	{	887	{
@@ -937,7 +938,7 @@ do_action: /* This label is used only to access EOF actions. */ · 50 unmodified lines
937	case 1:	938	case 1:
938	/* rule 1 can match eol */	939	/* rule 1 can match eol */
939	YY_RULE_SETUP	940	YY_RULE_SETUP
940	#line 69 "dtc-lexer.l"	941	#line 70 "dtc-lexer.l"
941	{	942	{
942	char *name = strchr(yytext, '\"') + 1;	943	char *name = strchr(yytext, '\"') + 1;
943	yytext[yyleng-1] = '\0';	944	yytext[yyleng-1] = '\0';
@@ -947,7 +948,7 @@ YY_RULE_SETUP · 3 unmodified lines
947	case 2:	948	case 2:
948	/* rule 2 can match eol */	949	/* rule 2 can match eol */
949	YY_RULE_SETUP	950	YY_RULE_SETUP
950	#line 75 "dtc-lexer.l"	951	#line 76 "dtc-lexer.l"
951	{	952	{
952	char line, fnstart, *fnend;	953	char line, fnstart, *fnend;
953	struct data fn;	954	struct data fn;
@@ -981,7 +982,7 @@ case YY_STATE_EOF(INITIAL): · 27 unmodified lines
981	case YY_STATE_EOF(BYTESTRING):	982	case YY_STATE_EOF(BYTESTRING):
982	case YY_STATE_EOF(PROPNODENAME):	983	case YY_STATE_EOF(PROPNODENAME):
983	case YY_STATE_EOF(V1):	984	case YY_STATE_EOF(V1):
984	#line 104 "dtc-lexer.l"	985	#line 105 "dtc-lexer.l"
985	{	986	{
986	if (!pop_input_file()) {	987	if (!pop_input_file()) {
987	yyterminate();	988	yyterminate();
@@ -991,7 +992,7 @@ case YY_STATE_EOF(V1): · 3 unmodified lines
991	case 3:	992	case 3:
992	/* rule 3 can match eol */	993	/* rule 3 can match eol */
993	YY_RULE_SETUP	994	YY_RULE_SETUP
994	#line 110 "dtc-lexer.l"	995	#line 111 "dtc-lexer.l"
995	{	996	{
996	DPRINT("String: %s\n", yytext);	997	DPRINT("String: %s\n", yytext);
997	yylval.data = data_copy_escape_string(yytext+1,	998	yylval.data = data_copy_escape_string(yytext+1,
@@ -1001,7 +1002,7 @@ YY_RULE_SETUP · 3 unmodified lines
1001	YY_BREAK	1002	YY_BREAK
1002	case 4:	1003	case 4:
1003	YY_RULE_SETUP	1004	YY_RULE_SETUP
1004	#line 117 "dtc-lexer.l"	1005	#line 118 "dtc-lexer.l"
1005	{	1006	{
1006	DPRINT("Keyword: /dts-v1/\n");	1007	DPRINT("Keyword: /dts-v1/\n");
1007	dts_version = 1;	1008	dts_version = 1;
@@ -1011,7 +1012,7 @@ YY_RULE_SETUP · 3 unmodified lines
1011	YY_BREAK	1012	YY_BREAK
1012	case 5:	1013	case 5:
1013	YY_RULE_SETUP	1014	YY_RULE_SETUP
1014	#line 124 "dtc-lexer.l"	1015	#line 125 "dtc-lexer.l"
1015	{	1016	{
1016	DPRINT("Keyword: /plugin/\n");	1017	DPRINT("Keyword: /plugin/\n");
1017	return DT_PLUGIN;	1018	return DT_PLUGIN;
@@ -1019,7 +1020,7 @@ YY_RULE_SETUP · 1 unmodified line
1019	YY_BREAK	1020	YY_BREAK
1020	case 6:	1021	case 6:
1021	YY_RULE_SETUP	1022	YY_RULE_SETUP
1022	#line 129 "dtc-lexer.l"	1023	#line 130 "dtc-lexer.l"
1023	{	1024	{
1024	DPRINT("Keyword: /memreserve/\n");	1025	DPRINT("Keyword: /memreserve/\n");
1025	BEGIN_DEFAULT();	1026	BEGIN_DEFAULT();
@@ -1028,7 +1029,7 @@ YY_RULE_SETUP · 2 unmodified lines
1028	YY_BREAK	1029	YY_BREAK
1029	case 7:	1030	case 7:
1030	YY_RULE_SETUP	1031	YY_RULE_SETUP
1031	#line 135 "dtc-lexer.l"	1032	#line 136 "dtc-lexer.l"
1032	{	1033	{
1033	DPRINT("Keyword: /bits/\n");	1034	DPRINT("Keyword: /bits/\n");
1034	BEGIN_DEFAULT();	1035	BEGIN_DEFAULT();
@@ -1037,7 +1038,7 @@ YY_RULE_SETUP · 2 unmodified lines
1037	YY_BREAK	1038	YY_BREAK
1038	case 8:	1039	case 8:
1039	YY_RULE_SETUP	1040	YY_RULE_SETUP
1040	#line 141 "dtc-lexer.l"	1041	#line 142 "dtc-lexer.l"
1041	{	1042	{
1042	DPRINT("Keyword: /delete-property/\n");	1043	DPRINT("Keyword: /delete-property/\n");
1043	DPRINT("<PROPNODENAME>\n");	1044	DPRINT("<PROPNODENAME>\n");
@@ -1047,7 +1048,7 @@ YY_RULE_SETUP · 3 unmodified lines
1047	YY_BREAK	1048	YY_BREAK
1048	case 9:	1049	case 9:
1049	YY_RULE_SETUP	1050	YY_RULE_SETUP
1050	#line 148 "dtc-lexer.l"	1051	#line 149 "dtc-lexer.l"
1051	{	1052	{
1052	DPRINT("Keyword: /delete-node/\n");	1053	DPRINT("Keyword: /delete-node/\n");
1053	DPRINT("<PROPNODENAME>\n");	1054	DPRINT("<PROPNODENAME>\n");
@@ -1057,7 +1058,7 @@ YY_RULE_SETUP · 3 unmodified lines
1057	YY_BREAK	1058	YY_BREAK
1058	case 10:	1059	case 10:
1059	YY_RULE_SETUP	1060	YY_RULE_SETUP
1060	#line 155 "dtc-lexer.l"	1061	#line 156 "dtc-lexer.l"
1061	{	1062	{
1062	DPRINT("Label: %s\n", yytext);	1063	DPRINT("Label: %s\n", yytext);
1063	yylval.labelref = xstrdup(yytext);	1064	yylval.labelref = xstrdup(yytext);
@@ -1067,7 +1068,7 @@ YY_RULE_SETUP · 3 unmodified lines
1067	YY_BREAK	1068	YY_BREAK
1068	case 11:	1069	case 11:
1069	YY_RULE_SETUP	1070	YY_RULE_SETUP
1070	#line 162 "dtc-lexer.l"	1071	#line 163 "dtc-lexer.l"
1071	{	1072	{
1072	char *e;	1073	char *e;
1073	DPRINT("Integer Literal: '%s'\n", yytext);	1074	DPRINT("Integer Literal: '%s'\n", yytext);
@@ -1093,7 +1094,7 @@ YY_RULE_SETUP · 19 unmodified lines
1093	case 12:	1094	case 12:
1094	/* rule 12 can match eol */	1095	/* rule 12 can match eol */
1095	YY_RULE_SETUP	1096	YY_RULE_SETUP
1096	#line 184 "dtc-lexer.l"	1097	#line 185 "dtc-lexer.l"
1097	{	1098	{
1098	struct data d;	1099	struct data d;
1099	DPRINT("Character literal: %s\n", yytext);	1100	DPRINT("Character literal: %s\n", yytext);
@@ -1117,7 +1118,7 @@ YY_RULE_SETUP · 17 unmodified lines
1117	YY_BREAK	1118	YY_BREAK
1118	case 13:	1119	case 13:
1119	YY_RULE_SETUP	1120	YY_RULE_SETUP
1120	#line 205 "dtc-lexer.l"	1121	#line 206 "dtc-lexer.l"
1121	{ /* label reference */	1122	{ /* label reference */
1122	DPRINT("Ref: %s\n", yytext+1);	1123	DPRINT("Ref: %s\n", yytext+1);
1123	yylval.labelref = xstrdup(yytext+1);	1124	yylval.labelref = xstrdup(yytext+1);
@@ -1126,7 +1127,7 @@ YY_RULE_SETUP · 2 unmodified lines
1126	YY_BREAK	1127	YY_BREAK
1127	case 14:	1128	case 14:
1128	YY_RULE_SETUP	1129	YY_RULE_SETUP
1129	#line 211 "dtc-lexer.l"	1130	#line 212 "dtc-lexer.l"
1130	{ /* new-style path reference */	1131	{ /* new-style path reference */
1131	yytext[yyleng-1] = '\0';	1132	yytext[yyleng-1] = '\0';
1132	DPRINT("Ref: %s\n", yytext+2);	1133	DPRINT("Ref: %s\n", yytext+2);
@@ -1136,7 +1137,7 @@ YY_RULE_SETUP · 3 unmodified lines
1136	YY_BREAK	1137	YY_BREAK
1137	case 15:	1138	case 15:
1138	YY_RULE_SETUP	1139	YY_RULE_SETUP
1139	#line 218 "dtc-lexer.l"	1140	#line 219 "dtc-lexer.l"
1140	{	1141	{
1141	yylval.byte = strtol(yytext, NULL, 16);	1142	yylval.byte = strtol(yytext, NULL, 16);
1142	DPRINT("Byte: %02x\n", (int)yylval.byte);	1143	DPRINT("Byte: %02x\n", (int)yylval.byte);
@@ -1145,7 +1146,7 @@ YY_RULE_SETUP · 2 unmodified lines
1145	YY_BREAK	1146	YY_BREAK
1146	case 16:	1147	case 16:
1147	YY_RULE_SETUP	1148	YY_RULE_SETUP
1148	#line 224 "dtc-lexer.l"	1149	#line 225 "dtc-lexer.l"
1149	{	1150	{
1150	DPRINT("/BYTESTRING\n");	1151	DPRINT("/BYTESTRING\n");
1151	BEGIN_DEFAULT();	1152	BEGIN_DEFAULT();
@@ -1154,7 +1155,7 @@ YY_RULE_SETUP · 2 unmodified lines
1154	YY_BREAK	1155	YY_BREAK
1155	case 17:	1156	case 17:
1156	YY_RULE_SETUP	1157	YY_RULE_SETUP
1157	#line 230 "dtc-lexer.l"	1158	#line 231 "dtc-lexer.l"
1158	{	1159	{
1159	DPRINT("PropNodeName: %s\n", yytext);	1160	DPRINT("PropNodeName: %s\n", yytext);
1160	yylval.propnodename = xstrdup((yytext[0] == '\\') ?	1161	yylval.propnodename = xstrdup((yytext[0] == '\\') ?
@@ -1165,7 +1166,7 @@ YY_RULE_SETUP · 4 unmodified lines
1165	YY_BREAK	1166	YY_BREAK
1166	case 18:	1167	case 18:
1167	YY_RULE_SETUP	1168	YY_RULE_SETUP
1168	#line 238 "dtc-lexer.l"	1169	#line 239 "dtc-lexer.l"
1169	{	1170	{
1170	DPRINT("Binary Include\n");	1171	DPRINT("Binary Include\n");
1171	return DT_INCBIN;	1172	return DT_INCBIN;
@@ -1174,64 +1175,64 @@ YY_RULE_SETUP · 2 unmodified lines
1174	case 19:	1175	case 19:
1175	/* rule 19 can match eol */	1176	/* rule 19 can match eol */
1176	YY_RULE_SETUP	1177	YY_RULE_SETUP
1177	#line 243 "dtc-lexer.l"	1178	#line 244 "dtc-lexer.l"
1178	/* eat whitespace */	1179	/* eat whitespace */
1179	YY_BREAK	1180	YY_BREAK
1180	case 20:	1181	case 20:
1181	/* rule 20 can match eol */	1182	/* rule 20 can match eol */
1182	YY_RULE_SETUP	1183	YY_RULE_SETUP
1183	#line 244 "dtc-lexer.l"	1184	#line 245 "dtc-lexer.l"
1184	/* eat C-style comments */	1185	/* eat C-style comments */
1185	YY_BREAK	1186	YY_BREAK
1186	case 21:	1187	case 21:
1187	/* rule 21 can match eol */	1188	/* rule 21 can match eol */
1188	YY_RULE_SETUP	1189	YY_RULE_SETUP
1189	#line 245 "dtc-lexer.l"	1190	#line 246 "dtc-lexer.l"
1190	/* eat C++-style comments */	1191	/* eat C++-style comments */
1191	YY_BREAK	1192	YY_BREAK
1192	case 22:	1193	case 22:
1193	YY_RULE_SETUP	1194	YY_RULE_SETUP
1194	#line 247 "dtc-lexer.l"	1195	#line 248 "dtc-lexer.l"
1195	{ return DT_LSHIFT; };	1196	{ return DT_LSHIFT; };
1196	YY_BREAK	1197	YY_BREAK
1197	case 23:	1198	case 23:
1198	YY_RULE_SETUP	1199	YY_RULE_SETUP
1199	#line 248 "dtc-lexer.l"	1200	#line 249 "dtc-lexer.l"
1200	{ return DT_RSHIFT; };	1201	{ return DT_RSHIFT; };
1201	YY_BREAK	1202	YY_BREAK
1202	case 24:	1203	case 24:
1203	YY_RULE_SETUP	1204	YY_RULE_SETUP
1204	#line 249 "dtc-lexer.l"	1205	#line 250 "dtc-lexer.l"
1205	{ return DT_LE; };	1206	{ return DT_LE; };
1206	YY_BREAK	1207	YY_BREAK
1207	case 25:	1208	case 25:
1208	YY_RULE_SETUP	1209	YY_RULE_SETUP
1209	#line 250 "dtc-lexer.l"	1210	#line 251 "dtc-lexer.l"
1210	{ return DT_GE; };	1211	{ return DT_GE; };
1211	YY_BREAK	1212	YY_BREAK
1212	case 26:	1213	case 26:
1213	YY_RULE_SETUP	1214	YY_RULE_SETUP
1214	#line 251 "dtc-lexer.l"	1215	#line 252 "dtc-lexer.l"
1215	{ return DT_EQ; };	1216	{ return DT_EQ; };
1216	YY_BREAK	1217	YY_BREAK
1217	case 27:	1218	case 27:
1218	YY_RULE_SETUP	1219	YY_RULE_SETUP
1219	#line 252 "dtc-lexer.l"	1220	#line 253 "dtc-lexer.l"
1220	{ return DT_NE; };	1221	{ return DT_NE; };
1221	YY_BREAK	1222	YY_BREAK
1222	case 28:	1223	case 28:
1223	YY_RULE_SETUP	1224	YY_RULE_SETUP
1224	#line 253 "dtc-lexer.l"	1225	#line 254 "dtc-lexer.l"
1225	{ return DT_AND; };	1226	{ return DT_AND; };
1226	YY_BREAK	1227	YY_BREAK
1227	case 29:	1228	case 29:
1228	YY_RULE_SETUP	1229	YY_RULE_SETUP
1229	#line 254 "dtc-lexer.l"	1230	#line 255 "dtc-lexer.l"
1230	{ return DT_OR; };	1231	{ return DT_OR; };
1231	YY_BREAK	1232	YY_BREAK
1232	case 30:	1233	case 30:
1233	YY_RULE_SETUP	1234	YY_RULE_SETUP
1234	#line 256 "dtc-lexer.l"	1235	#line 257 "dtc-lexer.l"
1235	{	1236	{
1236	DPRINT("Char: %c (\\x%02x)\n", yytext[0],	1237	DPRINT("Char: %c (\\x%02x)\n", yytext[0],
1237	(unsigned)yytext[0]);	1238	(unsigned)yytext[0]);
@@ -1249,10 +1250,10 @@ YY_RULE_SETUP · 11 unmodified lines
1249	YY_BREAK	1250	YY_BREAK
1250	case 31:	1251	case 31:
1251	YY_RULE_SETUP	1252	YY_RULE_SETUP
1252	#line 271 "dtc-lexer.l"	1253	#line 272 "dtc-lexer.l"
1253	ECHO;	1254	ECHO;
1254	YY_BREAK	1255	YY_BREAK
1255	#line 1256 "dtc-lexer.lex.c"	1256	#line 1257 "dtc-lexer.lex.c"
1256		1257
1257	case YY_END_OF_BUFFER:	1258	case YY_END_OF_BUFFER:
1258	{	1259	{
@@ -2218,7 +2219,7 @@ void yyfree (void * ptr ) · 959 unmodified lines
2218		2219
2219	#define YYTABLES_NAME "yytables"	2220	#define YYTABLES_NAME "yytables"
2220		2221
2221	#line 271 "dtc-lexer.l"	2222	#line 272 "dtc-lexer.l"
2222		2223
2223		2224
2224		2225

scripts/dtc/dtc-parser.tab.c_shipped+3−3

@@ -1557,10 +1557,10 @@ yyreduce: · 1556 unmodified lines
1557	{	1557	{
1558	struct node *target = get_node_by_ref((yyvsp[-3].node), (yyvsp[-1].labelref));	1558	struct node *target = get_node_by_ref((yyvsp[-3].node), (yyvsp[-1].labelref));
1559		1559
1560	add_label(&target->labels, (yyvsp[-2].labelref));	1560	if (target) {
1561	if (target)	1561	add_label(&target->labels, (yyvsp[-2].labelref));
1562	merge_nodes(target, (yyvsp[0].node));	1562	merge_nodes(target, (yyvsp[0].node));
1563	else	1563	} else
1564	ERROR(&(yylsp[-1]), "Label or path %s not found", (yyvsp[-1].labelref));	1564	ERROR(&(yylsp[-1]), "Label or path %s not found", (yyvsp[-1].labelref));
1565	(yyval.node) = (yyvsp[-3].node);	1565	(yyval.node) = (yyvsp[-3].node);
1566	}	1566	}

scripts/dtc/dtc-parser.y+3−3

@@ -171,10 +171,10 @@ devicetree: · 170 unmodified lines
171	{	171	{
172	struct node *target = get_node_by_ref($1, $3);	172	struct node *target = get_node_by_ref($1, $3);
173		173
174	add_label(&target->labels, $2);	174	if (target) {
175	if (target)	175	add_label(&target->labels, $2);
176	merge_nodes(target, $4);	176	merge_nodes(target, $4);
177	else	177	} else
178	ERROR(&@3, "Label or path %s not found", $3);	178	ERROR(&@3, "Label or path %s not found", $3);
179	$$ = $1;	179	$$ = $1;
180	}	180	}

scripts/dtc/dtc.c+5−4

 static const char *guess_input_format(const char *fname, const char *fallback)
 {
 	struct stat statbuf;
-	uint32_t magic;
+	fdt32_t magic;
 	FILE *f;
 	if (stat(fname, &statbuf) != 0)
 	}
 	fclose(f);
-	magic = fdt32_to_cpu(magic);
+	if (fdt32_to_cpu(magic) == FDT_MAGIC)
-	if (magic == FDT_MAGIC)
 		return "dtb";
 	return guess_type_by_name(fname, fallback);
 			alignsize = strtol(optarg, NULL, 0);
 			if (!is_power_of_2(alignsize))
 				die("Invalid argument \"%d\" to -a option\n",
-				    optarg);
+				    alignsize);
 			break;
 		case 'f':
 			force = true;
 	else
 		die("Unknown input format \"%s\"\n", inform);
+	dti->outname = outname;
 	if (depfile) {
 		fputc('\n', depfile);
 		fclose(depfile);

scripts/dtc/dtc.h+8−3

 #define debug(...)
 #endif
 #define DEFAULT_FDT_VERSION	17
 /*
 struct data data_merge(struct data d1, struct data d2);
 struct data data_append_cell(struct data d, cell_t word);
 struct data data_append_integer(struct data d, uint64_t word, int bits);
-struct data data_append_re(struct data d, const struct fdt_reserve_entry *re);
+struct data data_append_re(struct data d, uint64_t address, uint64_t size);
 struct data data_append_addr(struct data d, uint64_t addr);
 struct data data_append_byte(struct data d, uint8_t byte);
 struct data data_append_zeroes(struct data d, int len);
 	struct label *next;
 };
+struct bus_type {
+	const char *name;
+};
 struct property {
 	bool deleted;
 	char *name;
 	int addr_cells, size_cells;
 	struct label *labels;
+	const struct bus_type *bus;
 };
 #define for_each_label_withdel(l0, l) \
 /* Boot info (tree plus memreserve information */
 struct reserve_info {
-	struct fdt_reserve_entry re;
+	uint64_t address, size;
 	struct reserve_info *next;
 	struct reserve_info *reservelist;
 	uint32_t boot_cpuid_phys;
 	struct node *dt;		/* the device tree */
+	const char *outname;		/* filename being written to, "-" for stdout */
 };
 /* DTS version flags definitions */

scripts/dtc/flattree.c+26−32

 struct emitter {
 	void (*cell)(void *, cell_t);
-	void (*string)(void *, char *, int);
+	void (*string)(void *, const char *, int);
 	void (*align)(void *, int);
 	void (*data)(void *, struct data);
 	void (*beginnode)(void *, struct label *labels);
 	*dtbuf = data_append_cell(*dtbuf, val);
 }
-static void bin_emit_string(void *e, char *str, int len)
+static void bin_emit_string(void *e, const char *str, int len)
 {
 	struct data *dtbuf = e;
 		(val >> 8) & 0xff, val & 0xff);
 }
-static void asm_emit_string(void *e, char *str, int len)
+static void asm_emit_string(void *e, const char *str, int len)
 {
 	FILE *f = e;
-	char c = 0;
-	if (len != 0) {
+	if (len != 0)
-		/* XXX: ewww */
+		fprintf(f, "\t.string\t\"%.*s\"\n", len, str);
-		c = str[len];
+	else
-		str[len] = '\0';
+		fprintf(f, "\t.string\t\"%s\"\n", str);
-	}
-	fprintf(f, "\t.string\t\"%s\"\n", str);
-	if (len != 0) {
-		str[len] = c;
-	}
 }
 static void asm_emit_align(void *e, int a)
 		emit_offset_label(f, m->ref, m->offset);
 	while ((d.len - off) >= sizeof(uint32_t)) {
-		asm_emit_cell(e, fdt32_to_cpu(*((uint32_t *)(d.val+off))));
+		asm_emit_cell(e, fdt32_to_cpu(*((fdt32_t *)(d.val+off))));
 		off += sizeof(uint32_t);
 	}
 {
 	struct reserve_info *re;
 	struct data d = empty_data;
-	static struct fdt_reserve_entry null_re = {0,0};
 	int    j;
 	for (re = reservelist; re; re = re->next) {
-		d = data_append_re(d, &re->re);
+		d = data_append_re(d, re->address, re->size);
 	}
 	/*
 	 * Add additional reserved slots if the user asked for them.
 	 */
 	for (j = 0; j < reservenum; j++) {
-		d = data_append_re(d, &null_re);
+		d = data_append_re(d, 0, 0);
 	}
 	return d;
 			fprintf(f, "\t.globl\t%s\n", l->label);
 			fprintf(f, "%s:\n", l->label);
 		}
-		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->re.address >> 32));
+		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->address >> 32));
 		ASM_EMIT_BELONG(f, "0x%08x",
-				(unsigned int)(re->re.address & 0xffffffff));
+				(unsigned int)(re->address & 0xffffffff));
-		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->re.size >> 32));
+		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->size >> 32));
-		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->re.size & 0xffffffff));
+		ASM_EMIT_BELONG(f, "0x%08x", (unsigned int)(re->size & 0xffffffff));
 	}
 	for (i = 0; i < reservenum; i++) {
 		fprintf(f, "\t.long\t0, 0\n\t.long\t0, 0\n");
 static uint32_t flat_read_word(struct inbuf *inb)
 {
-	uint32_t val;
+	fdt32_t val;
 	assert(((inb->ptr - inb->base) % sizeof(val)) == 0);
 	 * First pass, count entries.
 	 */
 	while (1) {
+		uint64_t address, size;
 		flat_read_chunk(inb, &re, sizeof(re));
-		re.address  = fdt64_to_cpu(re.address);
+		address  = fdt64_to_cpu(re.address);
-		re.size = fdt64_to_cpu(re.size);
+		size = fdt64_to_cpu(re.size);
-		if (re.size == 0)
+		if (size == 0)
 			break;
-		new = build_reserve_entry(re.address, re.size);
+		new = build_reserve_entry(address, size);
 		reservelist = add_reserve_entry(reservelist, new);
 	}
 struct dt_info *dt_from_blob(const char *fname)
 {
 	FILE *f;
+	fdt32_t magic_buf, totalsize_buf;
 	uint32_t magic, totalsize, version, size_dt, boot_cpuid_phys;
 	uint32_t off_dt, off_str, off_mem_rsvmap;
 	int rc;
 	f = srcfile_relative_open(fname, NULL);
-	rc = fread(&magic, sizeof(magic), 1, f);
+	rc = fread(&magic_buf, sizeof(magic_buf), 1, f);
 	if (ferror(f))
 		die("Error reading DT blob magic number: %s\n",
 		    strerror(errno));
 			die("Mysterious short read reading magic number\n");
 	}
-	magic = fdt32_to_cpu(magic);
+	magic = fdt32_to_cpu(magic_buf);
 	if (magic != FDT_MAGIC)
 		die("Blob has incorrect magic number\n");
-	rc = fread(&totalsize, sizeof(totalsize), 1, f);
+	rc = fread(&totalsize_buf, sizeof(totalsize_buf), 1, f);
 	if (ferror(f))
 		die("Error reading DT blob size: %s\n", strerror(errno));
 	if (rc < 1) {
 			die("Mysterious short read reading blob size\n");
 	}
-	totalsize = fdt32_to_cpu(totalsize);
+	totalsize = fdt32_to_cpu(totalsize_buf);
 	if (totalsize < FDT_V1_SIZE)
 		die("DT blob size (%d) is too small\n", totalsize);

scripts/dtc/libfdt/fdt_rw.c+2−1

@@ -283,7 +283,8 @@ int fdt_setprop(void fdt, int nodeoffset, const char name, · 282 unmodified lines
283	if (err)	283	if (err)
284	return err;	284	return err;
285		285
286	memcpy(prop->data, val, len);	286	if (len)
		287	memcpy(prop->data, val, len);
287	return 0;	288	return 0;
288	}	289	}
289		290

scripts/dtc/libfdt/libfdt.h+50−1

 /* Low-level functions (you probably don't need these)                */
 /**********************************************************************/
+#ifndef SWIG /* This function is not useful in Python */
 const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);
+#endif
 static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
 {
 	return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);
 /**********************************************************************/
 /* General functions                                                  */
 /**********************************************************************/
 #define fdt_get_header(fdt, field) \
 	(fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
 #define fdt_magic(fdt)			(fdt_get_header(fdt, magic))
  * useful for finding subnodes based on a portion of a larger string,
  * such as a full path.
  */
+#ifndef SWIG /* Not available in Python */
 int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
 			       const char *name, int namelen);
+#endif
 /**
  * fdt_subnode_offset - find a subnode of a given node
  * @fdt: pointer to the device tree blob
  * Identical to fdt_path_offset(), but only consider the first namelen
  * characters of path as the path name.
  */
+#ifndef SWIG /* Not available in Python */
 int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);
+#endif
 /**
  * fdt_path_offset - find a tree node by its full path
  * Identical to fdt_get_property(), but only examine the first namelen
  * characters of name for matching the property name.
  */
+#ifndef SWIG /* Not available in Python */
 const struct fdt_property *fdt_get_property_namelen(const void *fdt,
 						    int nodeoffset,
 						    const char *name,
 						    int namelen, int *lenp);
+#endif
 /**
  * fdt_get_property - find a given property in a given node
  *		-FDT_ERR_BADSTRUCTURE,
  *		-FDT_ERR_TRUNCATED, standard meanings
  */
+#ifndef SWIG /* This function is not useful in Python */
 const void *fdt_getprop_by_offset(const void *fdt, int offset,
 				  const char **namep, int *lenp);
+#endif
 /**
  * fdt_getprop_namelen - get property value based on substring
  * Identical to fdt_getprop(), but only examine the first namelen
  * characters of name for matching the property name.
  */
+#ifndef SWIG /* Not available in Python */
 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
 				const char *name, int namelen, int *lenp);
 static inline void *fdt_getprop_namelen_w(void *fdt, int nodeoffset,
 	return (void *)(uintptr_t)fdt_getprop_namelen(fdt, nodeoffset, name,
 						      namelen, lenp);
 }
+#endif
 /**
  * fdt_getprop - retrieve the value of a given property
  * Identical to fdt_get_alias(), but only examine the first namelen
  * characters of name for matching the alias name.
  */
+#ifndef SWIG /* Not available in Python */
 const char *fdt_get_alias_namelen(const void *fdt,
 				  const char *name, int namelen);
+#endif
 /**
  * fdt_get_alias - retrieve the path referenced by a given alias
  * of the name. It is useful when you want to manipulate only one value of
  * an array and you have a string that doesn't end with \0.
  */
+#ifndef SWIG /* Not available in Python */
 int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
 					const char *name, int namelen,
 					uint32_t idx, const void *val,
 					int len);
+#endif
 /**
  * fdt_setprop_inplace - change a property's value, but not its size
  *	-FDT_ERR_BADSTRUCTURE,
  *	-FDT_ERR_TRUNCATED, standard meanings
  */
+#ifndef SWIG /* Not available in Python */
 int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
 			const void *val, int len);
+#endif
 /**
  * fdt_setprop_inplace_u32 - change the value of a 32-bit integer property
 #define fdt_setprop_string(fdt, nodeoffset, name, str) \
 	fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
+/**
+ * fdt_setprop_empty - set a property to an empty value
+ * @fdt: pointer to the device tree blob
+ * @nodeoffset: offset of the node whose property to change
+ * @name: name of the property to change
+ *
+ * fdt_setprop_empty() sets the value of the named property in the
+ * given node to an empty (zero length) value, or creates a new empty
+ * property if it does not already exist.
+ *
+ * This function may insert or delete data from the blob, and will
+ * therefore change the offsets of some existing nodes.
+ *
+ * returns:
+ *	0, on success
+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *		contain the new property value
+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *	-FDT_ERR_BADLAYOUT,
+ *	-FDT_ERR_BADMAGIC,
+ *	-FDT_ERR_BADVERSION,
+ *	-FDT_ERR_BADSTATE,
+ *	-FDT_ERR_BADSTRUCTURE,
+ *	-FDT_ERR_BADLAYOUT,
+ *	-FDT_ERR_TRUNCATED, standard meanings
+ */
+#define fdt_setprop_empty(fdt, nodeoffset, name) \
+	fdt_setprop((fdt), (nodeoffset), (name), NULL, 0)
 /**
  * fdt_appendprop - append to or create a property
  * @fdt: pointer to the device tree blob
  * creating subnodes based on a portion of a larger string, such as a
  * full path.
  */
+#ifndef SWIG /* Not available in Python */
 int fdt_add_subnode_namelen(void *fdt, int parentoffset,
 			    const char *name, int namelen);
+#endif
 /**
  * fdt_add_subnode - creates a new node

scripts/dtc/libfdt/libfdt_env.h+13−13

@@ -58,16 +58,16 @@ · 57 unmodified lines
58	#include <string.h>	58	#include <string.h>
59		59
60	#ifdef __CHECKER__	60	#ifdef __CHECKER__
61	#define __force __attribute__((force))	61	#define FDT_FORCE __attribute__((force))
62	#define __bitwise __attribute__((bitwise))	62	#define FDT_BITWISE __attribute__((bitwise))
63	#else	63	#else
64	#define __force	64	#define FDT_FORCE
65	#define __bitwise	65	#define FDT_BITWISE
66	#endif	66	#endif
67		67
68	typedef uint16_t __bitwise fdt16_t;	68	typedef uint16_t FDT_BITWISE fdt16_t;
69	typedef uint32_t __bitwise fdt32_t;	69	typedef uint32_t FDT_BITWISE fdt32_t;
70	typedef uint64_t __bitwise fdt64_t;	70	typedef uint64_t FDT_BITWISE fdt64_t;
71		71
72	#define EXTRACT_BYTE(x, n) ((unsigned long long)((uint8_t *)&x)[n])	72	#define EXTRACT_BYTE(x, n) ((unsigned long long)((uint8_t *)&x)[n])
73	#define CPU_TO_FDT16(x) ((EXTRACT_BYTE(x, 0) << 8) \| EXTRACT_BYTE(x, 1))	73	#define CPU_TO_FDT16(x) ((EXTRACT_BYTE(x, 0) << 8) \| EXTRACT_BYTE(x, 1))
@@ -80,29 +80,29 @@ typedef uint64_t __bitwise fdt64_t; · 6 unmodified lines
80		80
81	static inline uint16_t fdt16_to_cpu(fdt16_t x)	81	static inline uint16_t fdt16_to_cpu(fdt16_t x)
82	{	82	{
83	return (__force uint16_t)CPU_TO_FDT16(x);	83	return (FDT_FORCE uint16_t)CPU_TO_FDT16(x);
84	}	84	}
85	static inline fdt16_t cpu_to_fdt16(uint16_t x)	85	static inline fdt16_t cpu_to_fdt16(uint16_t x)
86	{	86	{
87	return (__force fdt16_t)CPU_TO_FDT16(x);	87	return (FDT_FORCE fdt16_t)CPU_TO_FDT16(x);
88	}	88	}
89		89
90	static inline uint32_t fdt32_to_cpu(fdt32_t x)	90	static inline uint32_t fdt32_to_cpu(fdt32_t x)
91	{	91	{
92	return (__force uint32_t)CPU_TO_FDT32(x);	92	return (FDT_FORCE uint32_t)CPU_TO_FDT32(x);
93	}	93	}
94	static inline fdt32_t cpu_to_fdt32(uint32_t x)	94	static inline fdt32_t cpu_to_fdt32(uint32_t x)
95	{	95	{
96	return (__force fdt32_t)CPU_TO_FDT32(x);	96	return (FDT_FORCE fdt32_t)CPU_TO_FDT32(x);
97	}	97	}
98		98
99	static inline uint64_t fdt64_to_cpu(fdt64_t x)	99	static inline uint64_t fdt64_to_cpu(fdt64_t x)
100	{	100	{
101	return (__force uint64_t)CPU_TO_FDT64(x);	101	return (FDT_FORCE uint64_t)CPU_TO_FDT64(x);
102	}	102	}
103	static inline fdt64_t cpu_to_fdt64(uint64_t x)	103	static inline fdt64_t cpu_to_fdt64(uint64_t x)
104	{	104	{
105	return (__force fdt64_t)CPU_TO_FDT64(x);	105	return (FDT_FORCE fdt64_t)CPU_TO_FDT64(x);
106	}	106	}
107	#undef CPU_TO_FDT64	107	#undef CPU_TO_FDT64
108	#undef CPU_TO_FDT32	108	#undef CPU_TO_FDT32

scripts/dtc/livetree.c+12−10

 	struct property *prop = node->proplist;
 	while (prop) {
-		if (!strcmp(prop->name, name)) {
+		if (streq(prop->name, name)) {
 			delete_property(prop);
 			return;
 		}
 	struct node *node = parent->children;
 	while (node) {
-		if (!strcmp(node->name, name)) {
+		if (streq(node->name, name)) {
 			delete_node(node);
 			return;
 		}
 	memset(new, 0, sizeof(*new));
-	new->re.address = address;
+	new->address = address;
-	new->re.size = size;
+	new->size = size;
 	return new;
 }
 cell_t propval_cell(struct property *prop)
 {
 	assert(prop->val.len == sizeof(cell_t));
-	return fdt32_to_cpu(*((cell_t *)prop->val.val));
+	return fdt32_to_cpu(*((fdt32_t *)prop->val.val));
 }
 struct property *get_property_by_label(struct node *tree, const char *label,
 	a = *((const struct reserve_info * const *)ax);
 	b = *((const struct reserve_info * const *)bx);
-	if (a->re.address < b->re.address)
+	if (a->address < b->address)
 		return -1;
-	else if (a->re.address > b->re.address)
+	else if (a->address > b->address)
 		return 1;
-	else if (a->re.size < b->re.size)
+	else if (a->size < b->size)
 		return -1;
-	else if (a->re.size > b->re.size)
+	else if (a->size > b->size)
 		return 1;
 	else
 		return 0;
 	xasprintf(&entry, "%s:%s:%u",
 			node->fullpath, prop->name, m->offset);
 	append_to_property(fn, m->ref, entry, strlen(entry) + 1);
+	free(entry);
 }
 static void generate_fixups_tree_internal(struct dt_info *dti,
 		struct node *refnode)
 {
 	struct node *wn, *nwn;	/* local fixup node, walk node, new */
-	uint32_t value_32;
+	fdt32_t value_32;
 	char **compp;
 	int i, depth;

scripts/dtc/srcpos.c+1−1

@@ -252,7 +252,7 @@ srcpos_string(struct srcpos *pos) · 251 unmodified lines
252	const char *fname = "<no-file>";	252	const char *fname = "<no-file>";
253	char *pos_str;	253	char *pos_str;
254		254
255	if (pos)	255	if (pos->file && pos->file->name)
256	fname = pos->file->name;	256	fname = pos->file->name;
257		257
258		258

scripts/dtc/srcpos.h+5−6

 #include <stdio.h>
 #include <stdbool.h>
+#include "util.h"
 struct srcfile_state {
 	FILE *f;
 extern struct srcpos *srcpos_copy(struct srcpos *pos);
 extern char *srcpos_string(struct srcpos *pos);
-extern void srcpos_verror(struct srcpos *pos, const char *prefix,
+extern void PRINTF(3, 0) srcpos_verror(struct srcpos *pos, const char *prefix,
-			  const char *fmt, va_list va)
+					const char *fmt, va_list va);
-	__attribute__((format(printf, 3, 0)));
+extern void PRINTF(3, 4) srcpos_error(struct srcpos *pos, const char *prefix,
-extern void srcpos_error(struct srcpos *pos, const char *prefix,
+				      const char *fmt, ...);
-			 const char *fmt, ...)
-	__attribute__((format(printf, 3, 4)));
 extern void srcpos_set_line(char *f, int l);

scripts/dtc/treesource.c+3−3

@@ -137,7 +137,7 @@ static void write_propval_string(FILE *f, struct data val) · 136 unmodified lines
137	static void write_propval_cells(FILE *f, struct data val)	137	static void write_propval_cells(FILE *f, struct data val)
138	{	138	{
139	void *propend = val.val + val.len;	139	void *propend = val.val + val.len;
140	cell_t cp = (cell_t )val.val;	140	fdt32_t cp = (fdt32_t )val.val;
141	struct marker *m = val.markers;	141	struct marker *m = val.markers;
142		142
143	fprintf(f, "<");	143	fprintf(f, "<");
@@ -275,8 +275,8 @@ void dt_to_source(FILE f, struct dt_info dti) · 131 unmodified lines
275	for_each_label(re->labels, l)	275	for_each_label(re->labels, l)
276	fprintf(f, "%s: ", l->label);	276	fprintf(f, "%s: ", l->label);
277	fprintf(f, "/memreserve/\t0x%016llx 0x%016llx;\n",	277	fprintf(f, "/memreserve/\t0x%016llx 0x%016llx;\n",
278	(unsigned long long)re->re.address,	278	(unsigned long long)re->address,
279	(unsigned long long)re->re.size);	279	(unsigned long long)re->size);
280	}	280	}
281		281
282	write_tree_source_node(f, dti->dt, 0);	282	write_tree_source_node(f, dti->dt, 0);

scripts/dtc/update-dtc-source.sh+19−1

@@ -36,10 +36,19 @@ DTC_SOURCE="checks.c data.c dtc.c dtc.h flattree.c fstree.c livetree.c srcpos.c · 35 unmodified lines
36	DTC_GENERATED="dtc-lexer.lex.c dtc-parser.tab.c dtc-parser.tab.h"	36	DTC_GENERATED="dtc-lexer.lex.c dtc-parser.tab.c dtc-parser.tab.h"
37	LIBFDT_SOURCE="Makefile.libfdt fdt.c fdt.h fdt_empty_tree.c fdt_ro.c fdt_rw.c fdt_strerror.c fdt_sw.c fdt_wip.c libfdt.h libfdt_env.h libfdt_internal.h"	37	LIBFDT_SOURCE="Makefile.libfdt fdt.c fdt.h fdt_empty_tree.c fdt_ro.c fdt_rw.c fdt_strerror.c fdt_sw.c fdt_wip.c libfdt.h libfdt_env.h libfdt_internal.h"
38		38
		39	get_last_dtc_version() {
		40	git log --oneline scripts/dtc/ \| grep 'upstream' \| head -1 \| sed -e 's/^.* $.*$/\1/'
		41	}
		42
		43	last_dtc_ver=$(get_last_dtc_version)
		44
39	# Build DTC	45	# Build DTC
40	cd $DTC_UPSTREAM_PATH	46	cd $DTC_UPSTREAM_PATH
41	make clean	47	make clean
42	make check	48	make check
		49	dtc_version=$(git describe HEAD)
		50	dtc_log=$(git log --oneline ${last_dtc_ver}..)
		51
43		52
44	# Copy the files into the Linux tree	53	# Copy the files into the Linux tree
45	cd $DTC_LINUX_PATH	54	cd $DTC_LINUX_PATH
@@ -60,4 +69,13 @@ sed -i -- 's/#include <libfdt_env.h>/#include "libfdt_env.h"/g' ./libfdt/libfdt. · 14 unmodified lines
60	sed -i -- 's/#include <fdt.h>/#include "fdt.h"/g' ./libfdt/libfdt.h	69	sed -i -- 's/#include <fdt.h>/#include "fdt.h"/g' ./libfdt/libfdt.h
61	git add ./libfdt/libfdt.h	70	git add ./libfdt/libfdt.h
62		71
63	git commit -e -v -m "scripts/dtc: Update to upstream version [CHANGEME]"	72	commit_msg=$(cat << EOF
		73	scripts/dtc: Update to upstream version ${dtc_version}
		74
		75	This adds the following commits from upstream:
		76
		77	${dtc_log}
		78	EOF
		79	)
		80
		81	git commit -e -v -s -m "${commit_msg}"

scripts/dtc/util.c+6−5

 		} while (s < data + len);
 	} else if ((len % 4) == 0) {
-		const uint32_t *cell = (const uint32_t *)data;
+		const fdt32_t *cell = (const fdt32_t *)data;
 		printf(" = <");
 		for (i = 0, len /= 4; i < len; i++)
 	}
 }
-void util_version(void)
+void NORETURN util_version(void)
 {
 	printf("Version: %s\n", DTC_VERSION);
 	exit(0);
 }
-void util_usage(const char *errmsg, const char *synopsis,
+void NORETURN util_usage(const char *errmsg, const char *synopsis,
-		const char *short_opts, struct option const long_opts[],
+			 const char *short_opts,
-		const char * const opts_help[])
+			 struct option const long_opts[],
+			 const char * const opts_help[])
 {
 	FILE *fp = errmsg ? stderr : stdout;
 	const char a_arg[] = "<arg>";

scripts/dtc/util.h+17−7

@@ -25,9 +25,17 @@ · 24 unmodified lines
25	* USA	25	* USA
26	*/	26	*/
27		27
		28	#ifdef __GNUC__
		29	#define PRINTF(i, j) __attribute__((format (printf, i, j)))
		30	#define NORETURN __attribute__((noreturn))
		31	#else
		32	#define PRINTF(i, j)
		33	#define NORETURN
		34	#endif
		35
28	#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))	36	#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
29		37
30	static inline void __attribute__((noreturn)) die(const char *str, ...)	38	static inline void NORETURN PRINTF(1, 2) die(const char *str, ...)
31	{	39	{
32	va_list ap;	40	va_list ap;
33		41
@@ -53,13 +61,14 @@ static inline void xrealloc(void p, size_t len) · 19 unmodified lines
53	void *new = realloc(p, len);	61	void *new = realloc(p, len);
54		62
55	if (!new)	63	if (!new)
56	die("realloc() failed (len=%d)\n", len);	64	die("realloc() failed (len=%zd)\n", len);
57		65
58	return new;	66	return new;
59	}	67	}
60		68
61	extern char xstrdup(const char s);	69	extern char xstrdup(const char s);
62	extern int xasprintf(char *strp, const char fmt, ...);	70
		71	extern int PRINTF(2, 3) xasprintf(char *strp, const char fmt, ...);
63	extern char join_path(const char path, const char *name);	72	extern char join_path(const char path, const char *name);
64		73
65	/**	74	/**
@@ -188,7 +197,7 @@ void utilfdt_print_data(const char *data, int len); · 122 unmodified lines
188	/**	197	/**
189	* Show source version and exit	198	* Show source version and exit
190	*/	199	*/
191	void util_version(void) __attribute__((noreturn));	200	void NORETURN util_version(void);
192		201
193	/**	202	/**
194	* Show usage and exit	203	* Show usage and exit
@@ -202,9 +211,10 @@ void util_version(void) __attribute__((noreturn)); · 7 unmodified lines
202	* @param long_opts The structure of long options	211	* @param long_opts The structure of long options
203	* @param opts_help An array of help strings (should align with long_opts)	212	* @param opts_help An array of help strings (should align with long_opts)
204	*/	213	*/
205	void util_usage(const char errmsg, const char synopsis,	214	void NORETURN util_usage(const char errmsg, const char synopsis,
206	const char *short_opts, struct option const long_opts[],	215	const char *short_opts,
207	const char * const opts_help[]) __attribute__((noreturn));	216	struct option const long_opts[],
		217	const char * const opts_help[]);
208		218
209	/**	219	/**
210	* Show usage and exit	220	* Show usage and exit

scripts/dtc/version_gen.h+1−1

@@ -1 +1 @@
1	#define DTC_VERSION "DTC 1.4.2-g0931cea3"	1	#define DTC_VERSION "DTC 1.4.4-g756ffc4f"