Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4201d057 authored by Rob Herring's avatar Rob Herring
Browse files

scripts/dtc: Update to upstream version v1.4.5-3-gb1a60033c110 



This adds the following commits from upstream:

b1a60033c110 tests: Add a test for overlays syntactic sugar
737b2df39cc8 overlay: Add syntactic sugar version of overlays
497432fd2131 checks: Use proper format modifier for size_t
22a65c5331c2 dtc: Bump version to v1.4.5
c575d8059fff Add fdtoverlay to .gitignore
b6a6f9490d19 fdtoverlay: Sanity check blob size
8c1eb1526d2d pylibfdt: Use Python2 explicitly
ee3d26f6960b checks: add interrupts property check
c1e7738988f5 checks: add gpio binding properties check
b3bbac02d5e3 checks: add phandle with arg property checks
fe50bd1ecc1d fdtget: Split out cell list display into a new function
62d812308d11 README: Add a note about test_tree1.dts
5bed86aee9e8 pylibfdt: Add support for fdt_subnode_offset()
46f31b65b3b3 pylibfdt: Add support for fdt_node_offset_by_phandle()
a3ae43723687 pylibfdt: Add support for fdt_parent_offset()
a198af80344c pylibfdt: Add support for fdt_get_phandle()
b9eba92ea50f tests: Return a failure code when any tests fail
155faf6cc209 pylibfdt: Use local pylibfdt module
50e5cd07f325 pylibfdt: Add a test for use of uint32_t
ab78860f09f5 pylibfdt: Add stdint include to fix uint32_t
36f511fb1113 tests: Add stacked overlay tests on fdtoverlay
1bb00655d3e5 fdt: Allow stacked overlays phandle references
a33c2247ac8d Introduce fdt_setprop_placeholder() method
0016f8c2aa32 dtc: change default phandles to ePAPR style instead of both
e3b9a9588a35 tests: fdtoverlay unit test
42409146f2db fdtoverlay: A tool that applies overlays
aae22722fc8d manual: Document missing options
13ce6e1c2fc4 dtc: fix sprintf() format string error, again
d990b8013889 Makefile: Fix build on MSYS2 and Cygwin
51f56dedf8ea Clean up shared library compile/link options
21a2bc896e3d Suppress expected error message in fdtdump test
2a42b14d0d03 dtc: check.c fix compile error
a10cb3c818d3 Fix get_node_by_path string equality check
548aea2c436a fdtdump: Discourage use of fdtdump
c2258841a785 fdtdump: Fix over-zealous version check
9067ee4be0e6 Fix a few whitespace and style nits
e56f2b07be38 pylibfdt: Use setup.py to build the swig file
896f1c133265 pylibfdt: Use Makefile constructs to implement NO_PYTHON
90db6d9989ca pylibfdt: Allow setup.py to operate stand-alone
e20d9658cd8f Add Coverity Scan support
b04a2cf08862 pylibfdt: Fix code style in setup.py
1c5170d3a466 pylibfdt: Rename libfdt.swig to libfdt.i
580a9f6c2880 Add a libfdt function to write a property placeholder
ab15256d8d02 pylibfdt: Use the call function to simplify the Makefile
9f2e3a3a1f19 pylibfdt: Use the correct libfdt version in the module
e91c652af215 pylibfdt: Enable installation of Python module
8a892fd85d94 pylibfdt: Allow building to be disabled
741cdff85d3e .travis.yml: Add builds with and without Python library prerequisites
14c4171f4f9a pylibfdt: Use package_dir to set the package directory
89a5062ab231 pylibfdt: Use environment to pass C flags and files
4e0e0d049757 pylibfdt: Allow pkg-config to be supplied in the environment
6afd7d9688f5 Correct typo: s/pylibgfdt/pylibfdt/

Signed-off-by: default avatarRob Herring <robh@kernel.org>
parent 43223230

scripts/dtc/checks.c

+281 −1
Original line number Original line Diff line number Diff line
@@ -873,7 +873,7 @@ static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct no 
	while (size--)

	while (size--)

		reg = (reg << 32) | fdt32_to_cpu(*(cells++));

		reg = (reg << 32) | fdt32_to_cpu(*(cells++));





	snprintf(unit_addr, sizeof(unit_addr), "%llx", (unsigned long long)reg);

	snprintf(unit_addr, sizeof(unit_addr), "%"PRIx64, reg);

	if (!streq(unitname, unit_addr))

	if (!streq(unitname, unit_addr))

		FAIL(c, dti, "Node %s simple-bus unit address format error, expected \"%s\"",

		FAIL(c, dti, "Node %s simple-bus unit address format error, expected \"%s\"",

		     node->fullpath, unit_addr);

		     node->fullpath, unit_addr);
@@ -956,6 +956,265 @@ static void check_obsolete_chosen_interrupt_controller(struct check *c, 
WARNING(obsolete_chosen_interrupt_controller,

WARNING(obsolete_chosen_interrupt_controller,

	check_obsolete_chosen_interrupt_controller, NULL);

	check_obsolete_chosen_interrupt_controller, NULL);





struct provider {

	const char *prop_name;

	const char *cell_name;

	bool optional;

};



static void check_property_phandle_args(struct check *c,

					  struct dt_info *dti,

				          struct node *node,

				          struct property *prop,

				          const struct provider *provider)

{

	struct node *root = dti->dt;

	int cell, cellsize = 0;



	if (prop->val.len % sizeof(cell_t)) {

		FAIL(c, dti, "property '%s' size (%d) is invalid, expected multiple of %zu in node %s",

		     prop->name, prop->val.len, sizeof(cell_t), node->fullpath);

		return;

	}



	for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {

		struct node *provider_node;

		struct property *cellprop;

		int phandle;



		phandle = propval_cell_n(prop, cell);

		/*

		 * Some bindings use a cell value 0 or -1 to skip over optional

		 * entries when each index position has a specific definition.

		 */

		if (phandle == 0 || phandle == -1) {

			cellsize = 0;

			continue;

		}



		/* If we have markers, verify the current cell is a phandle */

		if (prop->val.markers) {

			struct marker *m = prop->val.markers;

			for_each_marker_of_type(m, REF_PHANDLE) {

				if (m->offset == (cell * sizeof(cell_t)))

					break;

			}

			if (!m)

				FAIL(c, dti, "Property '%s', cell %d is not a phandle reference in %s",

				     prop->name, cell, node->fullpath);

		}



		provider_node = get_node_by_phandle(root, phandle);

		if (!provider_node) {

			FAIL(c, dti, "Could not get phandle node for %s:%s(cell %d)",

			     node->fullpath, prop->name, cell);

			break;

		}



		cellprop = get_property(provider_node, provider->cell_name);

		if (cellprop) {

			cellsize = propval_cell(cellprop);

		} else if (provider->optional) {

			cellsize = 0;

		} else {

			FAIL(c, dti, "Missing property '%s' in node %s or bad phandle (referred from %s:%s[%d])",

			     provider->cell_name,

			     provider_node->fullpath,

			     node->fullpath, prop->name, cell);

			break;

		}



		if (prop->val.len < ((cell + cellsize + 1) * sizeof(cell_t))) {

			FAIL(c, dti, "%s property size (%d) too small for cell size %d in %s",

			     prop->name, prop->val.len, cellsize, node->fullpath);

		}

	}

}



static void check_provider_cells_property(struct check *c,

					  struct dt_info *dti,

				          struct node *node)

{

	struct provider *provider = c->data;

	struct property *prop;



	prop = get_property(node, provider->prop_name);

	if (!prop)

		return;



	check_property_phandle_args(c, dti, node, prop, provider);

}

#define WARNING_PROPERTY_PHANDLE_CELLS(nm, propname, cells_name, ...) \

	static struct provider nm##_provider = { (propname), (cells_name), __VA_ARGS__ }; \

	WARNING(nm##_property, check_provider_cells_property, &nm##_provider, &phandle_references);



WARNING_PROPERTY_PHANDLE_CELLS(clocks, "clocks", "#clock-cells");

WARNING_PROPERTY_PHANDLE_CELLS(cooling_device, "cooling-device", "#cooling-cells");

WARNING_PROPERTY_PHANDLE_CELLS(dmas, "dmas", "#dma-cells");

WARNING_PROPERTY_PHANDLE_CELLS(hwlocks, "hwlocks", "#hwlock-cells");

WARNING_PROPERTY_PHANDLE_CELLS(interrupts_extended, "interrupts-extended", "#interrupt-cells");

WARNING_PROPERTY_PHANDLE_CELLS(io_channels, "io-channels", "#io-channel-cells");

WARNING_PROPERTY_PHANDLE_CELLS(iommus, "iommus", "#iommu-cells");

WARNING_PROPERTY_PHANDLE_CELLS(mboxes, "mboxes", "#mbox-cells");

WARNING_PROPERTY_PHANDLE_CELLS(msi_parent, "msi-parent", "#msi-cells", true);

WARNING_PROPERTY_PHANDLE_CELLS(mux_controls, "mux-controls", "#mux-control-cells");

WARNING_PROPERTY_PHANDLE_CELLS(phys, "phys", "#phy-cells");

WARNING_PROPERTY_PHANDLE_CELLS(power_domains, "power-domains", "#power-domain-cells");

WARNING_PROPERTY_PHANDLE_CELLS(pwms, "pwms", "#pwm-cells");

WARNING_PROPERTY_PHANDLE_CELLS(resets, "resets", "#reset-cells");

WARNING_PROPERTY_PHANDLE_CELLS(sound_dais, "sound-dais", "#sound-dai-cells");

WARNING_PROPERTY_PHANDLE_CELLS(thermal_sensors, "thermal-sensors", "#thermal-sensor-cells");



static bool prop_is_gpio(struct property *prop)

{

	char *str;



	/*

	 * *-gpios and *-gpio can appear in property names,

	 * so skip over any false matches (only one known ATM)

	 */

	if (strstr(prop->name, "nr-gpio"))

		return false;



	str = strrchr(prop->name, '-');

	if (str)

		str++;

	else

		str = prop->name;

	if (!(streq(str, "gpios") || streq(str, "gpio")))

		return false;



	return true;

}



static void check_gpios_property(struct check *c,

					  struct dt_info *dti,

				          struct node *node)

{

	struct property *prop;



	/* Skip GPIO hog nodes which have 'gpios' property */

	if (get_property(node, "gpio-hog"))

		return;



	for_each_property(node, prop) {

		struct provider provider;



		if (!prop_is_gpio(prop))

			continue;



		provider.prop_name = prop->name;

		provider.cell_name = "#gpio-cells";

		provider.optional = false;

		check_property_phandle_args(c, dti, node, prop, &provider);

	}



}

WARNING(gpios_property, check_gpios_property, NULL, &phandle_references);



static void check_deprecated_gpio_property(struct check *c,

					   struct dt_info *dti,

				           struct node *node)

{

	struct property *prop;



	for_each_property(node, prop) {

		char *str;



		if (!prop_is_gpio(prop))

			continue;



		str = strstr(prop->name, "gpio");

		if (!streq(str, "gpio"))

			continue;



		FAIL(c, dti, "'[*-]gpio' is deprecated, use '[*-]gpios' instead for %s:%s",

		     node->fullpath, prop->name);

	}



}

CHECK(deprecated_gpio_property, check_deprecated_gpio_property, NULL);



static bool node_is_interrupt_provider(struct node *node)

{

	struct property *prop;



	prop = get_property(node, "interrupt-controller");

	if (prop)

		return true;



	prop = get_property(node, "interrupt-map");

	if (prop)

		return true;



	return false;

}

static void check_interrupts_property(struct check *c,

				      struct dt_info *dti,

				      struct node *node)

{

	struct node *root = dti->dt;

	struct node *irq_node = NULL, *parent = node;

	struct property *irq_prop, *prop = NULL;

	int irq_cells, phandle;



	irq_prop = get_property(node, "interrupts");

	if (!irq_prop)

		return;



	if (irq_prop->val.len % sizeof(cell_t))

		FAIL(c, dti, "property '%s' size (%d) is invalid, expected multiple of %zu in node %s",

		     irq_prop->name, irq_prop->val.len, sizeof(cell_t),

		     node->fullpath);



	while (parent && !prop) {

		if (parent != node && node_is_interrupt_provider(parent)) {

			irq_node = parent;

			break;

		}



		prop = get_property(parent, "interrupt-parent");

		if (prop) {

			phandle = propval_cell(prop);

			irq_node = get_node_by_phandle(root, phandle);

			if (!irq_node) {

				FAIL(c, dti, "Bad interrupt-parent phandle for %s",

				     node->fullpath);

				return;

			}

			if (!node_is_interrupt_provider(irq_node))

				FAIL(c, dti,

				     "Missing interrupt-controller or interrupt-map property in %s",

				     irq_node->fullpath);



			break;

		}



		parent = parent->parent;

	}



	if (!irq_node) {

		FAIL(c, dti, "Missing interrupt-parent for %s", node->fullpath);

		return;

	}



	prop = get_property(irq_node, "#interrupt-cells");

	if (!prop) {

		FAIL(c, dti, "Missing #interrupt-cells in interrupt-parent %s",

		     irq_node->fullpath);

		return;

	}



	irq_cells = propval_cell(prop);

	if (irq_prop->val.len % (irq_cells * sizeof(cell_t))) {

		FAIL(c, dti,

		     "interrupts size is (%d), expected multiple of %d in %s",

		     irq_prop->val.len, (int)(irq_cells * sizeof(cell_t)),

		     node->fullpath);

	}

}

WARNING(interrupts_property, check_interrupts_property, &phandle_references);



static struct check *check_table[] = {

static struct check *check_table[] = {

	&duplicate_node_names, &duplicate_property_names,

	&duplicate_node_names, &duplicate_property_names,

	&node_name_chars, &node_name_format, &property_name_chars,

	&node_name_chars, &node_name_format, &property_name_chars,
@@ -987,6 +1246,27 @@ static struct check *check_table[] = { 
	&avoid_default_addr_size,

	&avoid_default_addr_size,

	&obsolete_chosen_interrupt_controller,

	&obsolete_chosen_interrupt_controller,





	&clocks_property,

	&cooling_device_property,

	&dmas_property,

	&hwlocks_property,

	&interrupts_extended_property,

	&io_channels_property,

	&iommus_property,

	&mboxes_property,

	&msi_parent_property,

	&mux_controls_property,

	&phys_property,

	&power_domains_property,

	&pwms_property,

	&resets_property,

	&sound_dais_property,

	&thermal_sensors_property,



	&deprecated_gpio_property,

	&gpios_property,

	&interrupts_property,



	&always_fail,

	&always_fail,

};

};

scripts/dtc/dtc-lexer.lex.c_shipped

+5 −5
Original line number Original line Diff line number Diff line
@@ -1397,7 +1397,7 @@ static int yy_get_next_buffer (void) 
{

{

    	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;

    	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;

	char *source = (yytext_ptr);

	char *source = (yytext_ptr);

	yy_size_t number_to_move, i;

	int number_to_move, i;

	int ret_val;

	int ret_val;





	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )

	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
@@ -1426,7 +1426,7 @@ static int yy_get_next_buffer (void) 
	/* Try to read more data. */

	/* Try to read more data. */





	/* First move last chars to start of buffer. */

	/* First move last chars to start of buffer. */

	number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;

	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);





	for ( i = 0; i < number_to_move; ++i )

	for ( i = 0; i < number_to_move; ++i )

		*(dest++) = *(source++);

		*(dest++) = *(source++);
@@ -1508,7 +1508,7 @@ static int yy_get_next_buffer (void) 
	else

	else

		ret_val = EOB_ACT_CONTINUE_SCAN;

		ret_val = EOB_ACT_CONTINUE_SCAN;





	if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {

	if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {

		/* Extend the array by 50%, plus the number we really need. */

		/* Extend the array by 50%, plus the number we really need. */

		int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);

		int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);

		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );

		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
@@ -1987,10 +1987,10 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) 
	YY_BUFFER_STATE b;

	YY_BUFFER_STATE b;

	char *buf;

	char *buf;

	yy_size_t n;

	yy_size_t n;

	yy_size_t i;

	int i;

    

    

	/* Get memory for full buffer, including space for trailing EOB's. */

	/* Get memory for full buffer, including space for trailing EOB's. */

	n = (yy_size_t) _yybytes_len + 2;

	n = (yy_size_t) (_yybytes_len + 2);

	buf = (char *) yyalloc(n  );

	buf = (char *) yyalloc(n  );

	if ( ! buf )

	if ( ! buf )

		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

scripts/dtc/dtc-parser.tab.c_shipped

+224 −206

File changed.

Preview size limit exceeded, changes collapsed.

scripts/dtc/dtc-parser.y

+17 −3
Original line number Original line Diff line number Diff line
@@ -182,10 +182,19 @@ devicetree: 
		{

		{

			struct node *target = get_node_by_ref($1, $2);

			struct node *target = get_node_by_ref($1, $2);





			if (target)

			if (target) {

				merge_nodes(target, $3);

				merge_nodes(target, $3);

			} else {

				/*

				 * We rely on the rule being always:

				 *   versioninfo plugindecl memreserves devicetree

				 * so $-1 is what we want (plugindecl)

				 */

				if ($<flags>-1 & DTSF_PLUGIN)

					add_orphan_node($1, $3, $2);

				else

				else

					ERROR(&@2, "Label or path %s not found", $2);

					ERROR(&@2, "Label or path %s not found", $2);

			}

			$$ = $1;

			$$ = $1;

		}

		}

	| devicetree DT_DEL_NODE DT_REF ';'

	| devicetree DT_DEL_NODE DT_REF ';'
@@ -200,6 +209,11 @@ devicetree: 




			$$ = $1;

			$$ = $1;

		}

		}

	| /* empty */

		{

			/* build empty node */

			$$ = name_node(build_node(NULL, NULL), "");

		}

	;

	;





nodedef:

nodedef:

scripts/dtc/dtc.c

+1 −1
Original line number Original line Diff line number Diff line
@@ -31,7 +31,7 @@ int reservenum; /* Number of memory reservation slots */ 
int minsize;		/* Minimum blob size */

int minsize;		/* Minimum blob size */

int padsize;		/* Additional padding to blob */

int padsize;		/* Additional padding to blob */

int alignsize;		/* Additional padding to blob accroding to the alignsize */

int alignsize;		/* Additional padding to blob accroding to the alignsize */

int phandle_format = PHANDLE_BOTH;	/* Use linux,phandle or phandle properties */

int phandle_format = PHANDLE_EPAPR;	/* Use linux,phandle or phandle properties */

int generate_symbols;	/* enable symbols & fixup support */

int generate_symbols;	/* enable symbols & fixup support */

int generate_fixups;		/* suppress generation of fixups on symbol support */

int generate_fixups;		/* suppress generation of fixups on symbol support */

int auto_label_aliases;		/* auto generate labels -> aliases */

int auto_label_aliases;		/* auto generate labels -> aliases */