dtc bus and unit address checks

Add PCI bridge and device node checks. We identify PCI bridges with 'device_type = "pci"' as only PCI bridges should set that property. For bridges, check that node name is pci or pcie, ranges and bus-range are present, and #address-cells and #size-cells are correct.

For devices, check the reg property fields are correct for the first element (the config address). Check that the unit address is formatted corectly based on the reg property. Device unit addresses are in the form DD or DD,F where DD is the device 0-0x1f and F is the function 0-7. Also, check that the bus number is within the expected range defined by bridge's bus-ranges.

Signed-off-by Rob Herring <[email protected]>

---
v3:
- Use bus_type ptr for matching bus types
- Add a name string to bus_type
- Add a bus-range check
- Improve the PCI device reg value checking
- Use streq/strneq
- fix FAIL call changes from current master

v2:
- Remove bus_type functions. Combine test for bus_type and bridge check into single check.
- Add a check that PCI bridge node name is pci or pcie.

 checks.c | 136 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 dtc.h    |   5 +++
 2 files changed, 141 insertions(+)

checks.c +1 -0

index 0e8b978c360c..5ed91ac50a10 100644
@@ -685,6 +685,138 @@ static void check_ranges_format(struct check *c, struct dt_info *dti,
 }
 WARNING(ranges_format, check_ranges_format, NULL, &addr_size_cells);
 
+static const struct bus_type pci_bus = {

checks.c +52 -0

+		return;
+
+	node->bus = &pci_bus;
+
+	if (!strneq(node->name, "pci", node->basenamelen) &&
+	    !strneq(node->name, "pcie", node->basenamelen))
+		FAIL(c, dti, "Node %s node name is not \"pci\" or \"pcie\"",
+			     node->fullpath);
+
+	prop = get_property(node, "ranges");
+	if (!prop)
+		FAIL(c, dti, "Node %s missing ranges for PCI bridge (or not a bridge)",
+			     node->fullpath);
+
+	if (node_addr_cells(node) != 3)
+		FAIL(c, dti, "Node %s incorrect #address-cells for PCI bridge",
+			     node->fullpath);
+	if (node_size_cells(node) != 2)
+		FAIL(c, dti, "Node %s incorrect #size-cells for PCI bridge",
+			     node->fullpath);
+
+	prop = get_property(node, "bus-range");
+	if (!prop) {
+		FAIL(c, dti, "Node %s missing bus-range for PCI bridge",
+			     node->fullpath);
+		return;
+	}
+	if (prop->val.len != (sizeof(cell_t) * 2)) {
+		FAIL(c, dti, "Node %s bus-range must be 2 cells",
+			     node->fullpath);
+		return;
+	}
+	cells = (cell_t *)prop->val.val;
+	if (fdt32_to_cpu(cells[0]) > fdt32_to_cpu(cells[1]))
+		FAIL(c, dti, "Node %s bus-range 1st cell must be less than or equal to 2nd cell",
+			     node->fullpath);
+	if (fdt32_to_cpu(cells[1]) > 0xff)
+		FAIL(c, dti, "Node %s bus-range maximum bus number must be less than 256",
+			     node->fullpath);
+}
+WARNING(pci_bridge, check_pci_bridge, NULL,
+	&device_type_is_string, &addr_size_cells);
+
+static void check_pci_device_bus_num(struct check *c, struct dt_info *dti, struct node *node)
+{
+	struct property *prop;
+	unsigned int bus_num, min_bus, max_bus;
+	cell_t *cells;
+
+	if (!node->parent || (node->parent->bus != &pci_bus))
+		return;
+

checks.c +63 -0

+	} else {
+		cells = (cell_t *)prop->val.val;
+		min_bus = fdt32_to_cpu(cells[0]);
+		max_bus = fdt32_to_cpu(cells[0]);
+	}
+	if ((bus_num < min_bus) || (bus_num > max_bus))
+		FAIL(c, dti, "Node %s PCI bus number %d out of range, expected (%d - %d)",
+		     node->fullpath, bus_num, min_bus, max_bus);
+}
+WARNING(pci_device_bus_num, check_pci_device_bus_num, NULL, &reg_format);
+
+static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct node *node)
+{
+	struct property *prop;
+	const char *unitname = get_unitname(node);
+	char unit_addr[5];
+	unsigned int dev, func, reg;
+	cell_t *cells;
+
+	if (!node->parent || (node->parent->bus != &pci_bus))
+		return;
+
+	prop = get_property(node, "reg");
+	if (!prop) {
+		FAIL(c, dti, "Node %s missing PCI reg property", node->fullpath);
+		return;
+	}
+
+	cells = (cell_t *)prop->val.val;
+	if (cells[1] || cells[2])
+		FAIL(c, dti, "Node %s PCI reg config space address cells 2 and 3 must be 0",
+			     node->fullpath);
+
+	reg = fdt32_to_cpu(cells[0]);
+	dev = (reg & 0xf800) >> 11;
+	func = (reg & 0x700) >> 8;
+
+	if (reg & 0xff000000)
+		FAIL(c, dti, "Node %s PCI reg address is not configuration space",
+			     node->fullpath);
+	if (reg & 0x000000ff)
+		FAIL(c, dti, "Node %s PCI reg config space address register number must be 0",
+			     node->fullpath);
+
+	if (func == 0) {
+		snprintf(unit_addr, sizeof(unit_addr), "%x", dev);
+		if (streq(unitname, unit_addr))
+			return;
+	}
+
+	snprintf(unit_addr, sizeof(unit_addr), "%x,%x", dev, func);
+	if (streq(unitname, unit_addr))
+		return;
+
+	FAIL(c, dti, "Node %s PCI unit address format error, expected \"%s\"",
+	     node->fullpath, unit_addr);
+}
+WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format);
+
 /*
  * Style checks
  */

@@ -757,6 +889,10 @@ static struct check *check_table[] = {
 
 	&unit_address_vs_reg,
 
+	&pci_bridge,
+	&pci_device_reg,
+	&pci_device_bus_num,
+
 	&avoid_default_addr_size,
 	&obsolete_chosen_interrupt_controller,
 

dtc.h +5 -0

index 1ac2a1e3a4a5..af67eef339b0 100644
@@ -136,6 +136,10 @@ struct label {
 	struct label *next;
 };
 
+struct bus_type {
+	const char *name;
+};
+
 struct property {
 	bool deleted;
 	char *name;

@@ -162,6 +166,7 @@ struct node {
 	int addr_cells, size_cells;
 
 	struct label *labels;
+	const struct bus_type *bus;
 };
 
 #define for_each_label_withdel(l0, l) \

Add checks to identify simple-bus bus types and checks for child devices. Simple-bus type is generally identified by "simple-bus" compatible string. We also treat the root as a simple-bus, but only for child nodes with reg property.

Signed-off-by Rob Herring <[email protected]>

---
v2:
- new patch

 checks.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

checks.c +4 -0

index 5ed91ac50a10..c4865b4c8da0 100644
@@ -817,6 +817,72 @@ static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no
 }
 WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format);
 
+static const struct bus_type simple_bus = {
+	.name = "simple-bus",
+};
+

checks.c +45 -0

+}
+WARNING(simple_bus_bridge, check_simple_bus_bridge, NULL, &addr_size_cells);
+
+static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct node *node)
+{
+	struct property *prop;
+	const char *unitname = get_unitname(node);
+	char unit_addr[17];
+	unsigned int size;
+	uint64_t reg = 0;
+	cell_t *cells = NULL;
+
+	if (!node->parent || (node->parent->bus != &simple_bus))
+		return;
+
+	prop = get_property(node, "reg");
+	if (prop)
+		cells = (cell_t *)prop->val.val;
+	else {
+		prop = get_property(node, "ranges");
+		if (prop && prop->val.len)
+			/* skip of child address */
+			cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
+	}
+
+	if (!cells) {
+		if (node->parent->parent && !(node->bus == &simple_bus))
+			FAIL(c, dti, "Node %s missing or empty reg/ranges property", node->fullpath);
+		return;
+	}
+
+	size = node_addr_cells(node->parent);
+	while (size--)
+		reg = (reg << 32) | fdt32_to_cpu(*(cells++));
+
+	snprintf(unit_addr, sizeof(unit_addr), "%lx", reg);
+	if (!streq(unitname, unit_addr))
+		FAIL(c, dti, "Node %s simple-bus unit address format error, expected \"%s\"",
+		     node->fullpath, unit_addr);
+}
+WARNING(simple_bus_reg, check_simple_bus_reg, NULL, &reg_format, &simple_bus_bridge);
+
 /*
  * Style checks
  */

@@ -893,6 +959,9 @@ static struct check *check_table[] = {
 	&pci_device_reg,
 	&pci_device_bus_num,
 
+	&simple_bus_bridge,
+	&simple_bus_reg,
+
 	&avoid_default_addr_size,
 	&obsolete_chosen_interrupt_controller,
 

Quoted 31 lines · Rob Herring

Add checks to identify simple-bus bus types and checks for child devices. Simple-bus type is generally identified by "simple-bus" compatible string. We also treat the root as a simple-bus, but only for child nodes with reg property.

Signed-off-by Rob Herring <[email protected]>

---
v2:
- new patch

 checks.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

checks.c +10 -0

index 5ed91ac50a10..c4865b4c8da0 100644
@@ -817,6 +817,72 @@ static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no
 }
 WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format);
 
+static const struct bus_type simple_bus = {
+     .name = "simple-bus",
+};
+
+static bool node_is_compatible(struct node *node, const char *compat)
+{
+     struct property *prop;
+     const char *str;
+
+     prop = get_property(node, "compatible");

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 833

Quoted 4 lines

checks.c +4 -0

+     if (!prop)
+             return false;
+
+     for (str = prop->val.val; str < prop->val.val + prop->val.len; str += strlen(str) + 1) {

This isn't safe if the compatible property is filled with garbage (not '\0' terminated) - the strlen() could access beyond the end of the property value.

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 843

Quoted 11 lines

checks.c +10 -0

+             if (streq(str, compat))
+                     return true;
+     }
+     return false;
+}
+
+static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
+{
+     if (node_is_compatible(node, "simple-bus") || !node->parent)
+             node->bus = &simple_bus;

I don't think it's correct to assume the root bus is always a simple-bus. If it is, it really should be listed explicitly in the root node's compatible property.

Quoted 32 lines · David Gibson

Quoted 31 lines · Rob Herring

Add checks to identify simple-bus bus types and checks for child devices. Simple-bus type is generally identified by "simple-bus" compatible string. We also treat the root as a simple-bus, but only for child nodes with reg property.

Signed-off-by Rob Herring <[email protected]>

---
v2:
- new patch

 checks.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

checks.c +10 -0

index 5ed91ac50a10..c4865b4c8da0 100644
@@ -817,6 +817,72 @@ static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no
 }
 WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format);
 
+static const struct bus_type simple_bus = {
+     .name = "simple-bus",
+};
+
+static bool node_is_compatible(struct node *node, const char *compat)
+{
+     struct property *prop;
+     const char *str;
+
+     prop = get_property(node, "compatible");

Quoted 8 lines

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 833

Quoted 4 lines

checks.c +4 -0

+     if (!prop)
+             return false;
+
+     for (str = prop->val.val; str < prop->val.val + prop->val.len; str += strlen(str) + 1) {

This isn't safe if the compatible property is filled with garbage (not '\0' terminated) - the strlen() could access beyond the end of the property value.

Okay, I guess I can check that prop->val.val[prop->val.len - 1] == 0 up front.

Quoted 16 lines

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 843

Quoted 12 lines

checks.c +10 -0

+             if (streq(str, compat))
+                     return true;
+     }
+     return false;
+}
+
+static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
+{
+     if (node_is_compatible(node, "simple-bus") || !node->parent)
+             node->bus = &simple_bus;

I don't think it's correct to assume the root bus is always a simple-bus. If it is, it really should be listed explicitly in the root node's compatible property.

It is in the sense that Linux treats the root the same and creates devices for top level children and then descends for nodes with "simple-bus".

And since unit addresses are a single address space for a given level, we can't have any other bus type. IOW, any other defined bus type like I2C is going to be a child of its controller.

Rob

Quoted 43 lines · Rob Herring

Quoted 32 lines · David Gibson

Quoted 31 lines · Rob Herring

Add checks to identify simple-bus bus types and checks for child devices. Simple-bus type is generally identified by "simple-bus" compatible string. We also treat the root as a simple-bus, but only for child nodes with reg property.

Signed-off-by Rob Herring <[email protected]>

---
v2:
- new patch

 checks.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

checks.c +10 -0

index 5ed91ac50a10..c4865b4c8da0 100644
@@ -817,6 +817,72 @@ static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no
 }
 WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format);
 
+static const struct bus_type simple_bus = {
+     .name = "simple-bus",
+};
+
+static bool node_is_compatible(struct node *node, const char *compat)
+{
+     struct property *prop;
+     const char *str;
+
+     prop = get_property(node, "compatible");

Quoted 8 lines

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 833

Quoted 4 lines

checks.c +4 -0

+     if (!prop)
+             return false;
+
+     for (str = prop->val.val; str < prop->val.val + prop->val.len; str += strlen(str) + 1) {

This isn't safe if the compatible property is filled with garbage (not '\0' terminated) - the strlen() could access beyond the end of the property value.

Quoted 1 line

Okay, I guess I can check that prop->val.val[prop->val.len - 1] == 0 up front.

Sure. Or use strnlen.

Quoted 17 lines

Quoted 16 lines

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 843

Quoted 12 lines

checks.c +10 -0

+             if (streq(str, compat))
+                     return true;
+     }
+     return false;
+}
+
+static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
+{
+     if (node_is_compatible(node, "simple-bus") || !node->parent)
+             node->bus = &simple_bus;

I don't think it's correct to assume the root bus is always a simple-bus. If it is, it really should be listed explicitly in the root node's compatible property.

Quoted 3 lines

It is in the sense that Linux treats the root the same and creates devices for top level children and then descends for nodes with "simple-bus".

Hmm.. where in Linux is that? I think that's a bug, technically speaking, traversing the root node's children without regard to the type of the root node.

Quoted 4 lines

And since unit addresses are a single address space for a given level, we can't have any other bus type. IOW, any other defined bus type like I2C is going to be a child of its controller.

Quoted 1 line

Rob

--

David Gibson                    | I'll have my music baroque, and my code
david AT gibson.dropbear.id.au  | minimalist, thank you.  NOT _the_ _other_
                                | _way_ _around_!

http://www.ozlabs.org/~dgibson

Quoted 43 lines · Rob Herring

Quoted 40 lines · David Gibson

Quoted 25 lines · Rob Herring

Add checks to identify simple-bus bus types and checks for child devices. Simple-bus type is generally identified by "simple-bus" compatible string. We also treat the root as a simple-bus, but only for child nodes with reg property.

Signed-off-by Rob Herring <[email protected]>

---
v2:
- new patch

 checks.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

checks.c +4 -0

index 5ed91ac50a10..c4865b4c8da0 100644
@@ -817,6 +817,72 @@ static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no
 }
 WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format);
 
+static const struct bus_type simple_bus = {
+     .name = "simple-bus",
+};
+

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 833

Quoted 10 lines

checks.c +10 -0

+static bool node_is_compatible(struct node *node, const char *compat)
+{
+     struct property *prop;
+     const char *str;
+
+     prop = get_property(node, "compatible");
+     if (!prop)
+             return false;
+
+     for (str = prop->val.val; str < prop->val.val + prop->val.len; str += strlen(str) + 1) {

This isn't safe if the compatible property is filled with garbage (not '\0' terminated) - the strlen() could access beyond the end of the property value.

Quoted 1 line

Okay, I guess I can check that prop->val.val[prop->val.len - 1] == 0 up front.

Sure. Or use strnlen.

Quoted 15 lines

Quoted 14 lines

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 843

Quoted 10 lines

checks.c +10 -0

+             if (streq(str, compat))
+                     return true;
+     }
+     return false;
+}
+
+static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
+{
+     if (node_is_compatible(node, "simple-bus") || !node->parent)
+             node->bus = &simple_bus;

I don't think it's correct to assume the root bus is always a simple-bus. If it is, it really should be listed explicitly in the root node's compatible property.

Quoted 3 lines

It is in the sense that Linux treats the root the same and creates devices for top level children and then descends for nodes with "simple-bus".

Hmm.. where in Linux is that? I think that's a bug, technically speaking, traversing the root node's children without regard to the type of the root node.

Quoted 44 lines · David Gibson

Quoted 43 lines · Rob Herring

Quoted 40 lines · David Gibson

Quoted 25 lines · Rob Herring

Add checks to identify simple-bus bus types and checks for child devices. Simple-bus type is generally identified by "simple-bus" compatible string. We also treat the root as a simple-bus, but only for child nodes with reg property.

Signed-off-by Rob Herring <[email protected]>

---
v2:
- new patch

 checks.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

checks.c +4 -0

index 5ed91ac50a10..c4865b4c8da0 100644
@@ -817,6 +817,72 @@ static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no
 }
 WARNING(pci_device_reg, check_pci_device_reg, NULL, &reg_format);
 
+static const struct bus_type simple_bus = {
+     .name = "simple-bus",
+};
+

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 833

Quoted 10 lines

checks.c +10 -0

+static bool node_is_compatible(struct node *node, const char *compat)
+{
+     struct property *prop;
+     const char *str;
+
+     prop = get_property(node, "compatible");
+     if (!prop)
+             return false;
+
+     for (str = prop->val.val; str < prop->val.val + prop->val.len; str += strlen(str) + 1) {

This isn't safe if the compatible property is filled with garbage (not '\0' terminated) - the strlen() could access beyond the end of the property value.

Quoted 3 lines

Quoted 1 line

Okay, I guess I can check that prop->val.val[prop->val.len - 1] == 0 up front.

Sure. Or use strnlen.

Duh...

Quoted 19 lines

Quoted 18 lines

Quoted 6 lines

Quoted 6 lines

checks.c +6 -0

+             if (streq(str, compat))
+                     return true;
+     }
+     return false;
+}
+

Quoted 8 lines

checks.c static void check_pci_device_reg(struct check *c, struct dt_info *dti, struct no · line 843

Quoted 4 lines

checks.c +4 -0

+static void check_simple_bus_bridge(struct check *c, struct dt_info *dti, struct node *node)
+{
+     if (node_is_compatible(node, "simple-bus") || !node->parent)
+             node->bus = &simple_bus;

I don't think it's correct to assume the root bus is always a simple-bus. If it is, it really should be listed explicitly in the root node's compatible property.

It is in the sense that Linux treats the root the same and creates devices for top level children and then descends for nodes with "simple-bus".

Quoted 3 lines

Hmm.. where in Linux is that? I think that's a bug, technically speaking, traversing the root node's children without regard to the type of the root node.

drivers/of/platform.c:of_platform_populate() which is called on the root node with "simple-bus" in the match table.

Plus I know we have some DT's like Tegra that didn't put all their devices under a bus (but should have). Maybe I should warn on that (i.e. warn on having unit-addresses without a bus type set on root).

Node name unit-addresses should generally never begin with 0x or leading 0s. Add warnings to check for these cases, but only for nodes without a known bus type as there should be better bus specific checks of the unit address in those cases. Any unit addresses that don't follow the general rule will need to add a new bus type. There aren't any known ones ATM.

Signed-off-by Rob Herring <[email protected]>

---
v3:
- Only run check if bus type is not set (moving to the end of the series as a result). The bus bridge checks also must be a dependency.

v2:
- Split into separate check from unit_address_vs_reg

 checks.c                       | 25 +++++++++++++++++++++++++
 tests/run_tests.sh             |  2 ++
 tests/unit-addr-leading-0s.dts | 12 ++++++++++++
 tests/unit-addr-leading-0x.dts | 12 ++++++++++++
 4 files changed, 51 insertions(+)
 create mode 100644 tests/unit-addr-leading-0s.dts
 create mode 100644 tests/unit-addr-leading-0x.dts

checks.c +25 -0

index c4865b4c8da0..537c27dc4082 100644
@@ -883,6 +883,30 @@ static void check_simple_bus_reg(struct check *c, struct dt_info *dti, struct no
 }
 WARNING(simple_bus_reg, check_simple_bus_reg, NULL, &reg_format, &simple_bus_bridge);
 
+static void check_unit_address_format(struct check *c, struct dt_info *dti,
+				      struct node *node)
+{
+	const char *unitname = get_unitname(node);
+
+	if (node->parent && node->parent->bus)
+		return;
+
+	if (!unitname[0])
+		return;
+
+	if (!strncmp(unitname, "0x", 2)) {
+		FAIL(c, dti, "Node %s unit name should not have leading \"0x\"",
+		    node->fullpath);
+		/* skip over 0x for next test */
+		unitname += 2;
+	}
+	if (unitname[0] == '0' && isxdigit(unitname[1]))
+		FAIL(c, dti, "Node %s unit name should not have leading 0s",
+		    node->fullpath);
+}
+WARNING(unit_address_format, check_unit_address_format, NULL,
+	&node_name_format, &pci_bridge, &simple_bus_bridge);
+
 /*
  * Style checks
  */

@@ -954,6 +978,7 @@ static struct check *check_table[] = {
 	&addr_size_cells, &reg_format, &ranges_format,
 
 	&unit_address_vs_reg,
+	&unit_address_format,
 
 	&pci_bridge,
 	&pci_device_reg,

tests/run_tests.sh +2 -0

index ed489dbdd269..0f5c3db79b80 100755
@@ -540,6 +540,8 @@ dtc_tests () {
     check_tests obsolete-chosen-interrupt-controller.dts obsolete_chosen_interrupt_controller
     check_tests reg-without-unit-addr.dts unit_address_vs_reg
     check_tests unit-addr-without-reg.dts unit_address_vs_reg
+    check_tests unit-addr-leading-0x.dts unit_address_format
+    check_tests unit-addr-leading-0s.dts unit_address_format
     run_sh_test dtc-checkfails.sh node_name_chars -- -I dtb -O dtb bad_node_char.dtb
     run_sh_test dtc-checkfails.sh node_name_format -- -I dtb -O dtb bad_node_format.dtb
     run_sh_test dtc-checkfails.sh prop_name_chars -- -I dtb -O dtb bad_prop_char.dtb

tests/unit-addr-leading-0s.dts new file +12 -0

new file mode 100644
index 000000000000..cc017e9431a2
@@ -0,0 +1,12 @@
+/dts-v1/;
+
+/ {
+	#address-cells = <1>;
+	#size-cells = <1>;
+
+	bus {
+		node@001 {
+			reg = <1 0>;
+		};
+	};
+};

tests/unit-addr-leading-0x.dts new file +12 -0

new file mode 100644
index 000000000000..74f19678c98c
@@ -0,0 +1,12 @@
+/dts-v1/;
+
+/ {
+	#address-cells = <1>;
+	#size-cells = <1>;
+
+	bus {
+		node@0x1 {
+			reg = <1 0>;
+		};
+	};
+};