Re: [U-Boot] [U-Boot, 3/3] dtoc: Add support for 32 or 64-bit addresses

On Mon, 19 Jun 2017, Simon Glass wrote:

When using 32-bit addresses dtoc works correctly. For 64-bit addresses it does not since it ignores the #address-cells and #size-cells properties.

Update the tool to use fdt64_t as the element type for reg properties when either the address or size is larger than one cell. Use the correct value so that C code can obtain the information from the device tree easily.

Add tests for the four combinations of address and size values (32/32, 64/64, 32/64, 64/32).

Signed-off-by: Simon Glass sjg@chromium.org Suggested-by: Heiko Stuebner heiko@sntech.de Reported-by: Kever Yang kever.yang@rock-chips.com

Reviewed-by: Philipp Tomsich philipp.tomsich@theobroma-systems.com Tested-by: Philipp Tomsich philipp.tomsich@theobroma-systems.com

See below for comments.

---

tools/dtoc/dtb_platdata.py | 59 +++++++++++ tools/dtoc/dtoc_test_addr32.dts | 27 +++++ tools/dtoc/dtoc_test_addr32_64.dts | 33 ++++++ tools/dtoc/dtoc_test_addr64.dts | 33 ++++++ tools/dtoc/dtoc_test_addr64_32.dts | 33 ++++++ tools/dtoc/test_dtoc.py | 212 +++++++++++++++++++++++++++++++++++++ 6 files changed, 397 insertions(+) create mode 100644 tools/dtoc/dtoc_test_addr32.dts create mode 100644 tools/dtoc/dtoc_test_addr32_64.dts create mode 100644 tools/dtoc/dtoc_test_addr64.dts create mode 100644 tools/dtoc/dtoc_test_addr64_32.dts

diff --git a/tools/dtoc/dtb_platdata.py b/tools/dtoc/dtb_platdata.py index f5841cbb88..3de1a20dbd 100644 --- a/tools/dtoc/dtb_platdata.py +++ b/tools/dtoc/dtb_platdata.py @@ -242,6 +242,64 @@ class DtbPlatdata(object): self._valid_nodes = [] return self.scan_node(self._fdt.GetRoot())

• @staticmethod
• def get_num_cells(node):

•    """Get the number of cells in addresses and sizes for this node
  

•    Args:
  

•        node: Node to check
  

•    Returns:
  

•        Tuple:
  

•            Number of address cells for this node
  

•            Number of size cells for this node
  

•    """
  

•    parent = node.parent
  

•    na, ns = 2, 2
  

•    if parent:
  

•        na_prop = parent.props.get('#address-cells')
  

•        ns_prop = parent.props.get('#size-cells')
  

•        if na_prop:
  

•            na = fdt_util.fdt32_to_cpu(na_prop.value)
  

•        if ns_prop:
  

•            ns = fdt_util.fdt32_to_cpu(ns_prop.value)
  

•    return na, ns
  

• def scan_reg_sizes(self):

•    """Scan for 64-bit 'reg' properties and update the values
  

•    This finds 'reg' properties with 64-bit data and converts the value to
  

•    an array of 64-values. This allows it to be output in a way that the
  

•    C code can read.
  

•    """
  

•    for node in self._valid_nodes:
  

•        reg = node.props.get('reg')
  

•        if not reg:
  

•            continue
  

•        na, ns = self.get_num_cells(node)
  

•        total = na + ns
  

•        if reg.type != fdt.TYPE_INT:
  

•            raise ValueError("Node '%s' reg property is not an int")
  

•        if len(reg.value) % total:
  

•            raise ValueError("Node '%s' reg property has %d cells "
  

•                    'which is not a multiple of na + ns = %d + %d)' %
  

•                    (node.name, len(reg.value), na, ns))
  

•        reg.na = na
  

•        reg.ns = ns
  

•        if na != 1 or ns != 1:
  

•            reg.type = fdt.TYPE_INT64
  

•            i = 0
  

•            new_value = []
  

•            val = reg.value
  

•            while i < len(val):
  

•                addr = fdt_util.fdt_cells_to_cpu(val[i:], reg.na)
  

•                i += na
  

•                size = fdt_util.fdt_cells_to_cpu(val[i:], reg.ns)
  

•                i += ns
  

If there's just a single element in the reg expression (e.g. reg = <1>), as will be the case for I2C or SPI devices, the type of reg.na will be str instead of list... thus causing a failures in fdt_cells_to_cpu.

•                new_value += [addr, size]
  

•            reg.value = new_value
  

• def scan_structs(self): """Scan the device tree building up the C structures we will use.

@@ -445,6 +503,7 @@ def run_steps(args, dtb_file, include_disabled, output): plat = DtbPlatdata(dtb_file, include_disabled) plat.scan_dtb() plat.scan_tree()

• plat.scan_reg_sizes() plat.setup_output(output) structs = plat.scan_structs() plat.scan_phandles()

diff --git a/tools/dtoc/dtoc_test_addr32.dts b/tools/dtoc/dtoc_test_addr32.dts new file mode 100644 index 0000000000..bcfdcae10b --- /dev/null +++ b/tools/dtoc/dtoc_test_addr32.dts @@ -0,0 +1,27 @@ +/*

• • Test device tree file for dtoc
• • Copyright 2017 Google, Inc
• • SPDX-License-Identifier: GPL-2.0+
• */
• /dts-v1/;

+/ {

• #address-cells = <1>;
• #size-cells = <1>;
• test1 {

• u-boot,dm-pre-reloc;
  

• compatible = "test1";
  

• reg = <0x1234 0x5678>;
  

• };
• test2 {

• u-boot,dm-pre-reloc;
  

• compatible = "test2";
  

• reg = <0x12345678 0x98765432 2 3>;
  

• };

+}; diff --git a/tools/dtoc/dtoc_test_addr32_64.dts b/tools/dtoc/dtoc_test_addr32_64.dts new file mode 100644 index 0000000000..1c96243310 --- /dev/null +++ b/tools/dtoc/dtoc_test_addr32_64.dts @@ -0,0 +1,33 @@ +/*

• • Test device tree file for dtoc
• • Copyright 2017 Google, Inc
• • SPDX-License-Identifier: GPL-2.0+
• */
• /dts-v1/;

+/ {

• #address-cells = <1>;
• #size-cells = <2>;
• test1 {

• u-boot,dm-pre-reloc;
  

• compatible = "test1";
  

• reg = <0x1234 0x5678 0x0>;
  

• };
• test2 {

• u-boot,dm-pre-reloc;
  

• compatible = "test2";
  

• reg = <0x12345678 0x98765432 0x10987654>;
  

• };
• test3 {

• u-boot,dm-pre-reloc;
  

• compatible = "test3";
  

• reg = <0x12345678 0x98765432 0x10987654 2 0 3>;
  

• };

+}; diff --git a/tools/dtoc/dtoc_test_addr64.dts b/tools/dtoc/dtoc_test_addr64.dts new file mode 100644 index 0000000000..4c0ad0ec36 --- /dev/null +++ b/tools/dtoc/dtoc_test_addr64.dts @@ -0,0 +1,33 @@ +/*

• • Test device tree file for dtoc
• • Copyright 2017 Google, Inc
• • SPDX-License-Identifier: GPL-2.0+
• */
• /dts-v1/;

+/ {

• #address-cells = <2>;
• #size-cells = <2>;
• test1 {

• u-boot,dm-pre-reloc;
  

• compatible = "test1";
  

• reg = /bits/ 64 <0x1234 0x5678>;
  

• };
• test2 {

• u-boot,dm-pre-reloc;
  

• compatible = "test2";
  

• reg = /bits/ 64 <0x1234567890123456 0x9876543210987654>;
  

• };
• test3 {

• u-boot,dm-pre-reloc;
  

• compatible = "test3";
  

• reg = /bits/ 64 <0x1234567890123456 0x9876543210987654 2 3>;
  

• };

+}; diff --git a/tools/dtoc/dtoc_test_addr64_32.dts b/tools/dtoc/dtoc_test_addr64_32.dts new file mode 100644 index 0000000000..c36f6b726e --- /dev/null +++ b/tools/dtoc/dtoc_test_addr64_32.dts @@ -0,0 +1,33 @@ +/*

• • Test device tree file for dtoc
• • Copyright 2017 Google, Inc
• • SPDX-License-Identifier: GPL-2.0+
• */
• /dts-v1/;

+/ {

• #address-cells = <2>;
• #size-cells = <1>;
• test1 {

• u-boot,dm-pre-reloc;
  

• compatible = "test1";
  

• reg = <0x1234 0x0 0x5678>;
  

• };
• test2 {

• u-boot,dm-pre-reloc;
  

• compatible = "test2";
  

• reg = <0x12345678 0x90123456 0x98765432>;
  

• };
• test3 {

• u-boot,dm-pre-reloc;
  

• compatible = "test3";
  

• reg = <0x12345678 0x90123456 0x98765432 0 2 3>;
  

• };

+}; diff --git a/tools/dtoc/test_dtoc.py b/tools/dtoc/test_dtoc.py index 35aa4c9817..d91ff88c85 100644 --- a/tools/dtoc/test_dtoc.py +++ b/tools/dtoc/test_dtoc.py @@ -268,4 +268,216 @@ U_BOOT_DEVICE(spl_test) = { \t.platdata_size\t= sizeof(dtv_spl_test), };

+''', data)

• def test_addresses64(self):

•    """Test output from a node with a 'reg' property with na=2, ns=2"""
  

•    dtb_file = get_dtb_file('dtoc_test_addr64.dts')
  

•    output = tools.GetOutputFilename('output')
  

•    dtb_platdata.run_steps(['struct'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <stdbool.h>
  

+#include <libfdt.h> +struct dtd_test1 { +\tfdt64_t\t\treg[2]; +}; +struct dtd_test2 { +\tfdt64_t\t\treg[2]; +}; +struct dtd_test3 { +\tfdt64_t\t\treg[4]; +}; +''', data)

•    dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <common.h>
  

+#include <dm.h> +#include <dt-structs.h>

+static struct dtd_test1 dtv_test1 = { +\t.reg\t\t\t= {0x1234, 0x5678}, +}; +U_BOOT_DEVICE(test1) = { +\t.name\t\t= "test1", +\t.platdata\t= &dtv_test1, +\t.platdata_size\t= sizeof(dtv_test1), +};

+static struct dtd_test2 dtv_test2 = { +\t.reg\t\t\t= {0x1234567890123456, 0x9876543210987654}, +}; +U_BOOT_DEVICE(test2) = { +\t.name\t\t= "test2", +\t.platdata\t= &dtv_test2, +\t.platdata_size\t= sizeof(dtv_test2), +};

+static struct dtd_test3 dtv_test3 = { +\t.reg\t\t\t= {0x1234567890123456, 0x9876543210987654, 0x2, 0x3}, +}; +U_BOOT_DEVICE(test3) = { +\t.name\t\t= "test3", +\t.platdata\t= &dtv_test3, +\t.platdata_size\t= sizeof(dtv_test3), +};

+''', data)

• def test_addresses32(self):

•    """Test output from a node with a 'reg' property with na=1, ns=1"""
  

•    dtb_file = get_dtb_file('dtoc_test_addr32.dts')
  

•    output = tools.GetOutputFilename('output')
  

•    dtb_platdata.run_steps(['struct'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <stdbool.h>
  

+#include <libfdt.h> +struct dtd_test1 { +\tfdt32_t\t\treg[2]; +}; +struct dtd_test2 { +\tfdt32_t\t\treg[4]; +}; +''', data)

•    dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <common.h>
  

+#include <dm.h> +#include <dt-structs.h>

+static struct dtd_test1 dtv_test1 = { +\t.reg\t\t\t= {0x1234, 0x5678}, +}; +U_BOOT_DEVICE(test1) = { +\t.name\t\t= "test1", +\t.platdata\t= &dtv_test1, +\t.platdata_size\t= sizeof(dtv_test1), +};

+static struct dtd_test2 dtv_test2 = { +\t.reg\t\t\t= {0x12345678, 0x98765432, 0x2, 0x3}, +}; +U_BOOT_DEVICE(test2) = { +\t.name\t\t= "test2", +\t.platdata\t= &dtv_test2, +\t.platdata_size\t= sizeof(dtv_test2), +};

+''', data)

• def test_addresses64_32(self):

•    """Test output from a node with a 'reg' property with na=2, ns=1"""
  

•    dtb_file = get_dtb_file('dtoc_test_addr64_32.dts')
  

•    output = tools.GetOutputFilename('output')
  

•    dtb_platdata.run_steps(['struct'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <stdbool.h>
  

+#include <libfdt.h> +struct dtd_test1 { +\tfdt64_t\t\treg[2]; +}; +struct dtd_test2 { +\tfdt64_t\t\treg[2]; +}; +struct dtd_test3 { +\tfdt64_t\t\treg[4]; +}; +''', data)

•    dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <common.h>
  

+#include <dm.h> +#include <dt-structs.h>

+static struct dtd_test1 dtv_test1 = { +\t.reg\t\t\t= {0x123400000000, 0x5678}, +}; +U_BOOT_DEVICE(test1) = { +\t.name\t\t= "test1", +\t.platdata\t= &dtv_test1, +\t.platdata_size\t= sizeof(dtv_test1), +};

+static struct dtd_test2 dtv_test2 = { +\t.reg\t\t\t= {0x1234567890123456, 0x98765432}, +}; +U_BOOT_DEVICE(test2) = { +\t.name\t\t= "test2", +\t.platdata\t= &dtv_test2, +\t.platdata_size\t= sizeof(dtv_test2), +};

+static struct dtd_test3 dtv_test3 = { +\t.reg\t\t\t= {0x1234567890123456, 0x98765432, 0x2, 0x3}, +}; +U_BOOT_DEVICE(test3) = { +\t.name\t\t= "test3", +\t.platdata\t= &dtv_test3, +\t.platdata_size\t= sizeof(dtv_test3), +};

+''', data)

• def test_addresses32_64(self):

•    """Test output from a node with a 'reg' property with na=1, ns=2"""
  

•    dtb_file = get_dtb_file('dtoc_test_addr32_64.dts')
  

•    output = tools.GetOutputFilename('output')
  

•    dtb_platdata.run_steps(['struct'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <stdbool.h>
  

+#include <libfdt.h> +struct dtd_test1 { +\tfdt64_t\t\treg[2]; +}; +struct dtd_test2 { +\tfdt64_t\t\treg[2]; +}; +struct dtd_test3 { +\tfdt64_t\t\treg[4]; +}; +''', data)

•    dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
  

•    with open(output) as infile:
  

•        data = infile.read()
  

•    self.assertEqual('''#include <common.h>
  

+#include <dm.h> +#include <dt-structs.h>

+static struct dtd_test1 dtv_test1 = { +\t.reg\t\t\t= {0x1234, 0x567800000000}, +}; +U_BOOT_DEVICE(test1) = { +\t.name\t\t= "test1", +\t.platdata\t= &dtv_test1, +\t.platdata_size\t= sizeof(dtv_test1), +};

+static struct dtd_test2 dtv_test2 = { +\t.reg\t\t\t= {0x12345678, 0x9876543210987654}, +}; +U_BOOT_DEVICE(test2) = { +\t.name\t\t= "test2", +\t.platdata\t= &dtv_test2, +\t.platdata_size\t= sizeof(dtv_test2), +};

+static struct dtd_test3 dtv_test3 = { +\t.reg\t\t\t= {0x12345678, 0x9876543210987654, 0x2, 0x3}, +}; +U_BOOT_DEVICE(test3) = { +\t.name\t\t= "test3", +\t.platdata\t= &dtv_test3, +\t.platdata_size\t= sizeof(dtv_test3), +};

''', data)