From: Tom Rini trini@konsulko.com

The most portable way to get access to coverage is to invoke it as 'python-coverage'.

Cc: Simon Glass sjg@chromium.org Signed-off-by: Tom Rini trini@konsulko.com Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/README | 3 +-- tools/binman/binman.py | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/tools/binman/README b/tools/binman/README index 22f21bc5b44..f74e39242f6 100644 --- a/tools/binman/README +++ b/tools/binman/README @@ -583,8 +583,7 @@ implementations target 100% test coverage. Run 'binman -T' to check this.

To enable Python test coverage on Debian-type distributions (e.g. Ubuntu):

- $ sudo apt-get install python-pip python-pytest - $ sudo pip install coverage + $ sudo apt-get install python-coverage python-pytest

Advanced Features / Technical docs diff --git a/tools/binman/binman.py b/tools/binman/binman.py index 31b045337d2..f3044ca2124 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -81,11 +81,11 @@ def RunTests(debug, args): def RunTestCoverage(): """Run the tests and check that we get 100% coverage""" # This uses the build output from sandbox_spl to get _libfdt.so - cmd = ('PYTHONPATH=$PYTHONPATH:%s/sandbox_spl/tools coverage run ' + cmd = ('PYTHONPATH=$PYTHONPATH:%s/sandbox_spl/tools python-coverage run ' '--include "tools/binman/*.py" --omit "*test*,*binman.py" ' 'tools/binman/binman.py -t' % options.build_dir) os.system(cmd) - stdout = command.Output('coverage', 'report') + stdout = command.Output('python-coverage', 'report') lines = stdout.splitlines()

test_set= set([os.path.basename(line.split()[0])

At present we call the three entries first, second and third. Rename them to reflect their contents instead, for clarity.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/ftest.py | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index eb8a0793cbe..80eadeffab8 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -689,29 +689,40 @@ class TestFunctional(unittest.TestCase): self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])

def _RunMicrocodeTest(self, dts_fname, nodtb_data): + """Handle running a test for insertion of microcode + + Args: + dts_fname: Name of test .dts file + nodtb_data: Data that we expect in the first section + + Returns: + Tuple: + Contents of first region (U-Boot or SPL) + Position and size components of microcode pointer, as inserted + in the above (two 4-byte words) + """ data = self._DoReadFile(dts_fname, True)

# Now check the device tree has no microcode - second = data[len(nodtb_data):] + dtb_with_ucode = data[len(nodtb_data):] + fdt_len = self.GetFdtLen(dtb_with_ucode) + ucode_content = dtb_with_ucode[fdt_len:] + ucode_pos = len(nodtb_data) + fdt_len fname = tools.GetOutputFilename('test.dtb') with open(fname, 'wb') as fd: - fd.write(second) + fd.write(dtb_with_ucode) dtb = fdt.FdtScan(fname) ucode = dtb.GetNode('/microcode') self.assertTrue(ucode) for node in ucode.subnodes: self.assertFalse(node.props.get('data'))

- fdt_len = self.GetFdtLen(second) - third = second[fdt_len:] - # Check that the microcode appears immediately after the Fdt # This matches the concatenation of the data properties in # the /microcode/update@xxx nodes in 34_x86_ucode.dts. ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000, 0x78235609) - self.assertEqual(ucode_data, third[:len(ucode_data)]) - ucode_pos = len(nodtb_data) + fdt_len + self.assertEqual(ucode_data, ucode_content[:len(ucode_data)])

# Check that the microcode pointer was inserted. It should match the # expected position and size

Move all the test execution into the same mechanism so that we can request a particular test (from any suite) by passing it as an argument to 'binman -t'.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/binman.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/tools/binman/binman.py b/tools/binman/binman.py index f3044ca2124..9bdf2237528 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -54,14 +54,12 @@ def RunTests(debug, args):

# Run the entry tests first ,since these need to be the first to import the # 'entry' module. - suite = unittest.TestLoader().loadTestsFromTestCase(entry_test.TestEntry) - suite.run(result) test_name = args and args[0] or None - for module in (ftest.TestFunctional, fdt_test.TestFdt, elf_test.TestElf, - image_test.TestImage): + for module in (entry_test.TestEntry, ftest.TestFunctional, fdt_test.TestFdt, + elf_test.TestElf, image_test.TestImage): if test_name: try: - suite = unittest.TestLoader().loadTestsFromName(args[0], module) + suite = unittest.TestLoader().loadTestsFromName(test_name, module) except AttributeError: continue else:

This provides various patches sent to the devicetree-compiler mailing list to enhance the Python bindings. A final version of this patch may be created once upstreaming is complete, but if it takes too long, this can act as a placeholder.

New pylibfdt features: - Support for most remaining, relevant libfdt functions - Support for sequential-write functions

Changes are applied to existing U-Boot tools as needed.

Signed-off-by: Simon Glass sjg@chromium.org ---

scripts/dtc/libfdt/libfdt.h | 3 + scripts/dtc/pylibfdt/libfdt.i_shipped | 705 +++++++++++++++++++++++--- tools/dtoc/dtoc.py | 20 +- tools/dtoc/fdt.py | 3 +- tools/dtoc/test_dtoc.py | 3 +- 5 files changed, 663 insertions(+), 71 deletions(-)

diff --git a/scripts/dtc/libfdt/libfdt.h b/scripts/dtc/libfdt/libfdt.h index 7f83023ee10..c30aaaeac64 100644 --- a/scripts/dtc/libfdt/libfdt.h +++ b/scripts/dtc/libfdt/libfdt.h @@ -1310,10 +1310,13 @@ static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val) fdt64_t tmp = cpu_to_fdt64(val); return fdt_property(fdt, name, &tmp, sizeof(tmp)); } + +#ifndef SWIG /* Not available in Python */ static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val) { return fdt_property_u32(fdt, name, val); } +#endif

/** * fdt_property_placeholder - add a new property and return a ptr to its value diff --git a/scripts/dtc/pylibfdt/libfdt.i_shipped b/scripts/dtc/pylibfdt/libfdt.i_shipped index 2c1c987c1d1..6774b93b2cb 100644 --- a/scripts/dtc/pylibfdt/libfdt.i_shipped +++ b/scripts/dtc/pylibfdt/libfdt.i_shipped @@ -12,6 +12,17 @@ %{ #define SWIG_FILE_WITH_INIT #include "libfdt.h" + +/* + * We rename this function here to avoid problems with swig, since we also have + * a struct called fdt_property. That struct causes swig to create a class in + * libfdt.py called fdt_property(), which confuses things. + */ +static int _fdt_property(void *fdt, const char *name, const char *val, int len) +{ + return fdt_property(fdt, name, val, len); +} + %}

%pythoncode %{ @@ -108,6 +119,7 @@ def check_err_null(val, quiet=()): raise FdtException(val) return val

+ class Fdt: """Device tree class, supporting all operations

@@ -129,6 +141,163 @@ class Fdt: self._fdt = bytearray(data) check_err(fdt_check_header(self._fdt));

+ def as_bytearray(self): + """Get the device tree contents as a bytearray + + This can be passed directly to libfdt functions that access a + const void * for the device tree. + + Returns: + bytearray containing the device tree + """ + return bytearray(self._fdt) + + def next_node(self, nodeoffset, depth, quiet=()): + """Find the next subnode + + Args: + nodeoffset: Node offset of previous node + depth: On input, the depth of the node at nodeoffset. On output, the + depth of the returned node + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + The offset of the next node, if any + + Raises: + FdtException if no more nodes found or other error occurs + """ + return check_err(fdt_next_node(self._fdt, nodeoffset, depth), quiet) + + def first_subnode(self, nodeoffset, quiet=()): + """Find the first subnode of a parent node + + Args: + nodeoffset: Node offset of parent node + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + The offset of the first subnode, if any + + Raises: + FdtException if no subnodes found or other error occurs + """ + return check_err(fdt_first_subnode(self._fdt, nodeoffset), quiet) + + def next_subnode(self, nodeoffset, quiet=()): + """Find the next subnode + + Args: + nodeoffset: Node offset of previous subnode + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + The offset of the next subnode, if any + + Raises: + FdtException if no more subnodes found or other error occurs + """ + return check_err(fdt_next_subnode(self._fdt, nodeoffset), quiet) + + def magic(self): + """Return the magic word from the header + + Returns: + Magic word + """ + return fdt_magic(self._fdt) & 0xffffffff + + def totalsize(self): + """Return the total size of the device tree + + Returns: + Total tree size in bytes + """ + return check_err(fdt_totalsize(self._fdt)) + + def off_dt_struct(self): + """Return the start of the device-tree struct area + + Returns: + Start offset of struct area + """ + return check_err(fdt_off_dt_struct(self._fdt)) + + def off_dt_strings(self): + """Return the start of the device-tree string area + + Returns: + Start offset of string area + """ + return check_err(fdt_off_dt_strings(self._fdt)) + + def off_mem_rsvmap(self): + """Return the start of the memory reserve map + + Returns: + Start offset of memory reserve map + """ + return check_err(fdt_off_mem_rsvmap(self._fdt)) + + def version(self): + """Return the version of the device tree + + Returns: + Version number of the device tree + """ + return check_err(fdt_version(self._fdt)) + + def last_comp_version(self): + """Return the last compatible version of the device tree + + Returns: + Last compatible version number of the device tree + """ + return check_err(fdt_last_comp_version(self._fdt)) + + def boot_cpuid_phys(self): + """Return the physical boot CPU ID + + Returns: + Physical boot CPU ID + """ + return check_err(fdt_boot_cpuid_phys(self._fdt)) + + def size_dt_strings(self): + """Return the start of the device-tree string area + + Returns: + Start offset of string area + """ + return check_err(fdt_size_dt_strings(self._fdt)) + + def size_dt_struct(self): + """Return the start of the device-tree struct area + + Returns: + Start offset of struct area + """ + return check_err(fdt_size_dt_struct(self._fdt)) + + def num_mem_rsv(self, quiet=()): + """Return the number of memory reserve-map records + + Returns: + Number of memory reserve-map records + """ + return check_err(fdt_num_mem_rsv(self._fdt), quiet) + + def get_mem_rsv(self, index, quiet=()): + """Return the indexed memory reserve-map record + + Args: + index: Record to return (0=first) + + Returns: + Number of memory reserve-map records + """ + return check_err(fdt_get_mem_rsv(self._fdt, index), quiet) + def subnode_offset(self, parentoffset, name, quiet=()): """Get the offset of a named subnode

@@ -161,6 +330,20 @@ class Fdt: """ return check_err(fdt_path_offset(self._fdt, path), quiet)

+ def get_name(self, nodeoffset): + """Get the name of a node + + Args: + nodeoffset: Offset of node to check + + Returns: + Node name + + Raises: + FdtException on error (e.g. nodeoffset is invalid) + """ + return check_err_null(fdt_get_name(self._fdt, nodeoffset))[0] + def first_property_offset(self, nodeoffset, quiet=()): """Get the offset of the first property in a node offset

@@ -195,20 +378,6 @@ class Fdt: return check_err(fdt_next_property_offset(self._fdt, prop_offset), quiet)

- def get_name(self, nodeoffset): - """Get the name of a node - - Args: - nodeoffset: Offset of node to check - - Returns: - Node name - - Raises: - FdtException on error (e.g. nodeoffset is invalid) - """ - return check_err_null(fdt_get_name(self._fdt, nodeoffset))[0] - def get_property_by_offset(self, prop_offset, quiet=()): """Obtains a property that can be examined

@@ -229,51 +398,38 @@ class Fdt: return pdata return Property(pdata[0], pdata[1])

- def first_subnode(self, nodeoffset, quiet=()): - """Find the first subnode of a parent node + @staticmethod + def create_empty_tree(size, quiet=()): + """Create an empty device tree ready for use

Args: - nodeoffset: Node offset of parent node - quiet: Errors to ignore (empty to raise on all errors) + size: Size of device tree in bytes

Returns: - The offset of the first subnode, if any - - Raises: - FdtException if no subnode found or other error occurs + Fdt object containing the device tree """ - return check_err(fdt_first_subnode(self._fdt, nodeoffset), quiet) - - def next_subnode(self, nodeoffset, quiet=()): - """Find the next subnode + data = bytearray(size) + err = check_err(fdt_create_empty_tree(data, size), quiet) + if err: + return err + return Fdt(data)

- Args: - nodeoffset: Node offset of previous subnode - quiet: Errors to ignore (empty to raise on all errors) + def open_into(self, size, quiet=()): + """Move the device tree into a larger or smaller space

- Returns: - The offset of the next subnode, if any + This creates a new device tree of size @size and moves the existing + device tree contents over to that. It can be used to create more space + in a device tree.

- Raises: - FdtException if no more subnode found or other error occurs - """ - return check_err(fdt_next_subnode(self._fdt, nodeoffset), quiet) - - def totalsize(self): - """Return the total size of the device tree - - Returns: - Total tree size in bytes - """ - return check_err(fdt_totalsize(self._fdt)) - - def off_dt_struct(self): - """Return the start of the device tree struct area - - Returns: - Start offset of struct area + Args: + size: Required new size of device tree in bytes """ - return check_err(fdt_off_dt_struct(self._fdt)) + fdt = bytearray(size) + fdt[:len(self._fdt)] = self._fdt + err = check_err(fdt_open_into(self._fdt, fdt, size), quiet) + if err: + return err + self._fdt = fdt

def pack(self, quiet=()): """Pack the device tree to remove unused space @@ -288,20 +444,28 @@ class Fdt: """ return check_err(fdt_pack(self._fdt), quiet)

- def delprop(self, nodeoffset, prop_name): - """Delete a property from a node + def getprop(self, nodeoffset, prop_name, quiet=()): + """Get a property from a node

Args: - nodeoffset: Node offset containing property to delete - prop_name: Name of property to delete + nodeoffset: Node offset containing property to get + prop_name: Name of property to get + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + Value of property as a string, or -ve error number

Raises: - FdtError if the property does not exist, or another error occurs + FdtError if any error occurs (e.g. the property is not found) """ - return check_err(fdt_delprop(self._fdt, nodeoffset, prop_name)) + pdata = check_err_null(fdt_getprop(self._fdt, nodeoffset, prop_name), + quiet) + if isinstance(pdata, (int)): + return pdata + return str(pdata[0])

- def getprop(self, nodeoffset, prop_name, quiet=()): - """Get a property from a node + def getprop_obj(self, nodeoffset, prop_name, quiet=()): + """Get a property from a node as a Property object

Args: nodeoffset: Node offset containing property to get @@ -309,7 +473,7 @@ class Fdt: quiet: Errors to ignore (empty to raise on all errors)

Returns: - Value of property as a bytearray, or -ve error number + Property object, or None if not found

Raises: FdtError if any error occurs (e.g. the property is not found) @@ -317,8 +481,8 @@ class Fdt: pdata = check_err_null(fdt_getprop(self._fdt, nodeoffset, prop_name), quiet) if isinstance(pdata, (int)): - return pdata - return bytearray(pdata[0]) + return None + return Property(prop_name, bytearray(pdata[0]))

def get_phandle(self, nodeoffset): """Get the phandle of a node @@ -347,6 +511,108 @@ class Fdt: """ return check_err(fdt_parent_offset(self._fdt, nodeoffset), quiet)

+ def set_name(self, nodeoffset, name, quiet=()): + """Set the name of a node + + Args: + nodeoffset: Node offset of node to update + name: New node name + + Returns: + Error code, or 0 if OK + + Raises: + FdtException if no parent found or other error occurs + """ + return check_err(fdt_set_name(self._fdt, nodeoffset, name), quiet) + + def setprop(self, nodeoffset, prop_name, val, quiet=()): + """Set the value of a property + + Args: + nodeoffset: Node offset containing the property to create/update + prop_name: Name of property + val: Value to write (string or bytearray) + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + Error code, or 0 if OK + + Raises: + FdtException if no parent found or other error occurs + """ + return check_err(fdt_setprop(self._fdt, nodeoffset, prop_name, val, + len(val)), quiet) + + def setprop_u32(self, nodeoffset, prop_name, val, quiet=()): + """Set the value of a property + + Args: + nodeoffset: Node offset containing the property to create/update + prop_name: Name of property + val: Value to write (integer) + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + Error code, or 0 if OK + + Raises: + FdtException if no parent found or other error occurs + """ + return check_err(fdt_setprop_u32(self._fdt, nodeoffset, prop_name, val), + quiet) + + def setprop_u64(self, nodeoffset, prop_name, val, quiet=()): + """Set the value of a property + + Args: + nodeoffset: Node offset containing the property to create/update + prop_name: Name of property + val: Value to write (integer) + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + Error code, or 0 if OK + + Raises: + FdtException if no parent found or other error occurs + """ + return check_err(fdt_setprop_u64(self._fdt, nodeoffset, prop_name, val), + quiet) + + def setprop_str(self, nodeoffset, prop_name, val, quiet=()): + """Set the string value of a property + + The property is set to the string, with a nul terminator added + + Args: + nodeoffset: Node offset containing the property to create/update + prop_name: Name of property + val: Value to write (string without nul terminator) + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + Error code, or 0 if OK + + Raises: + FdtException if no parent found or other error occurs + """ + val += '\0' + return check_err(fdt_setprop(self._fdt, nodeoffset, prop_name, + val, len(val)), quiet) + + def delprop(self, nodeoffset, prop_name): + """Delete a property from a node + + Args: + nodeoffset: Node offset containing property to delete + prop_name: Name of property to delete + + Raises: + FdtError if the property does not exist, or another error occurs + """ + return check_err(fdt_delprop(self._fdt, nodeoffset, prop_name)) + def node_offset_by_phandle(self, phandle, quiet=()): """Get the offset of a node with the given phandle

@@ -362,7 +628,8 @@ class Fdt: """ return check_err(fdt_node_offset_by_phandle(self._fdt, phandle), quiet)

-class Property: + +class Property(bytearray): """Holds a device tree property name and value.

This holds a copy of a property taken from the device tree. It does not @@ -371,11 +638,274 @@ class Property:

Properties: name: Property name - value: Proper value as a bytearray + value: Property value as a bytearray """ def __init__(self, name, value): + bytearray.__init__(self, value) self.name = name - self.value = value + + def as_cell(self, fmt): + return struct.unpack('>' + fmt, self)[0] + + def as_uint32(self): + return self.as_cell('L') + + def as_int32(self): + return self.as_cell('l') + + def as_uint64(self): + return self.as_cell('Q') + + def as_int64(self): + return self.as_cell('q') + + def as_str(self): + return self[:-1] + + +class FdtSw(object): + """Software interface to create a device tree from scratch + + The methods in this class work by adding to an existing 'partial' device + tree buffer of a fixed size created by instantiating this class. When the + tree is complete, call finish() to complete the device tree so that it can + be used. + + Similarly with nodes, a new node is started with begin_node() and finished + with end_node(). + + The context manager functions can be used to make this a bit easier: + + # First create the device tree with a node and property: + with FdtSw(small_size) as sw: + with sw.AddNode('node'): + sw.property_u32('reg', 2) + fdt = sw.AsFdt() + + # Now we can use it as a real device tree + fdt.setprop_u32(0, 'reg', 3) + """ + def __init__(self, size, quiet=()): + fdtrw = bytearray(size) + err = check_err(fdt_create(fdtrw, size)) + if err: + return err + self._fdtrw = fdtrw + + def __enter__(self): + """Contact manager to use to create a device tree via software""" + return self + + def __exit__(self, type, value, traceback): + check_err(fdt_finish(self._fdtrw)) + + def AsFdt(self): + """Convert a FdtSw into an Fdt so it can be accessed as normal + + Note that finish() must be called before this function will work. If + you are using the context manager (see 'with' code in the FdtSw class + comment) then this will happen automatically. + + Returns: + Fdt object allowing access to the newly created device tree + """ + return Fdt(self._fdtrw) + + def resize(self, size, quiet=()): + """Resize the buffer to accommodate a larger tree + + Args: + size: New size of tree + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + fdt = bytearray(size) + fdt[:len(self._fdtrw)] = self._fdtrw + err = check_err(fdt_resize(self._fdtrw, fdt, size), quiet) + if err: + return err + self._fdtrw = fdt + + def add_reservemap_entry(self, addr, size, quiet=()): + """Add a new memory reserve map entry + + Once finished adding, you must call finish_reservemap(). + + Args: + addr: 64-bit start address + size: 64-bit size + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_add_reservemap_entry(self._fdtrw, addr, size), + quiet) + + def finish_reservemap(self, quiet=()): + """Indicate that there are no more reserve map entries to add + + Args: + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_finish_reservemap(self._fdtrw), quiet) + + def begin_node(self, name, quiet=()): + """Begin a new node + + Use this before adding properties to the node. Then call end_node() to + finish it. You can also use the context manager as shown in the FdtSw + class comment. + + Args: + name: Name of node to begin + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_begin_node(self._fdtrw, name), quiet) + + def property_string(self, name, string, quiet=()): + """Add a property with a string value + + The string will be nul-terminated when written to the device tree + + Args: + name: Name of property to add + string: String value of property + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_property_string(self._fdtrw, name, string), quiet) + + def property_u32(self, name, val, quiet=()): + """Add a property with a 32-bit value + + Write a single-cell value to the device tree + + Args: + name: Name of property to add + val: Value of property + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_property_u32(self._fdtrw, name, val), quiet) + + def property_u64(self, name, val, quiet=()): + """Add a property with a 64-bit value + + Write a double-cell value to the device tree in big-endian format + + Args: + name: Name of property to add + val: Value of property + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_property_u64(self._fdtrw, name, val), quiet) + + def property_cell(self, name, val, quiet=()): + """Add a property with a single-cell value + + Write a single-cell value to the device tree + + Args: + name: Name of property to add + val: Value of property + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_property_cell(self._fdtrw, name, val), quiet) + + def property(self, name, val, quiet=()): + """Add a property + + Write a new property with the given value to the device tree. The value + is taken as is and is not nul-terminated + + Args: + name: Name of property to add + val: Value of property + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(_fdt_property(self._fdtrw, name, val, len(val)), quiet) + + def end_node(self, quiet=()): + """End a node + + Use this after adding properties to a node to close it off. You can also + use the context manager as shown in the FdtSw class comment. + + Args: + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_end_node(self._fdtrw), quiet) + + def finish(self, quiet=()): + """Finish writing the device tree + + This closes off the device tree ready for use + + Args: + quiet: Errors to ignore (empty to raise on all errors) + + Raises: + FdtException if no node found or other error occurs + """ + return check_err(fdt_finish(self._fdtrw), quiet) + + def AddNode(self, name): + """Create a new context for adding a node + + When used in a 'with' clause this starts a new node and finishes it + afterward. + + Args: + name: Name of node to add + """ + return NodeAdder(self._fdtrw, name) + + +class NodeAdder(): + """Class to provide a node context + + This allows you to add nodes in a more natural way: + + with fdtsw.AddNode('name'): + fdtsw.property_string('test', 'value') + + The node is automatically completed with a call to end_node() when the + context exits. + """ + def __init__(self, fdt, name): + self._fdt = fdt + self._name = name + + def __enter__(self): + check_err(fdt_begin_node(self._fdt, self._name)) + + def __exit__(self, type, value, traceback): + check_err(fdt_end_node(self._fdt)) %}

%rename(fdt_property) fdt_property_func; @@ -408,6 +938,7 @@ typedef int fdt32_t; fdt = fdt; /* avoid unused variable warning */ }

+/* typemap used for fdt_get_property_by_offset() */ %typemap(out) (struct fdt_property *) { PyObject *buff;

@@ -430,6 +961,44 @@ typedef int fdt32_t; $result = Py_BuildValue("s#", $1, *arg4); }

+/* typemap used for fdt_setprop() */ +%typemap(in) (const void *val) { + $1 = PyString_AsString($input); /* char *str */ +} + +/* typemap used for fdt_add_reservemap_entry() */ +%typemap(in) uint64_t { + $1 = PyLong_AsUnsignedLong($input); +} + +/* typemaps used for fdt_next_node() */ +%typemap(in, numinputs=1) int *depth (int depth) { + depth = (int) PyInt_AsLong($input); + $1 = &depth; +} + +%typemap(argout) int *depth { + PyObject *val = Py_BuildValue("i", *arg$argnum); + resultobj = SWIG_Python_AppendOutput(resultobj, val); +} + +%apply int *depth { int *depth }; + +/* typemaps for fdt_get_mem_rsv */ +%typemap(in, numinputs=0) uint64_t * (uint64_t temp) { + $1 = &temp; +} + +%typemap(argout) uint64_t * { + PyObject *val = PyLong_FromUnsignedLong(*arg$argnum); + if (!result) { + if (PyTuple_GET_SIZE(resultobj) == 0) + resultobj = val; + else + resultobj = SWIG_Python_AppendOutput(resultobj, val); + } +} + /* We have both struct fdt_property and a function fdt_property() */ %warnfilter(302) fdt_property;

@@ -444,5 +1013,13 @@ int fdt_last_comp_version(const void *fdt); int fdt_boot_cpuid_phys(const void *fdt); int fdt_size_dt_strings(const void *fdt); int fdt_size_dt_struct(const void *fdt); +int fdt_property_string(void *fdt, const char *name, const char *val); +int fdt_property_cell(void *fdt, const char *name, uint32_t val); + +/* + * This function has a stub since the name fdt_property is used for both a + * function and a struct, which confuses SWIG. + */ +int _fdt_property(void *fdt, const char *name, const char *val, int len);

%include <../libfdt/libfdt.h> diff --git a/tools/dtoc/dtoc.py b/tools/dtoc/dtoc.py index 008c0f4d693..c891b063800 100755 --- a/tools/dtoc/dtoc.py +++ b/tools/dtoc/dtoc.py @@ -36,14 +36,26 @@ sys.path.append(os.path.join(our_path, '../patman'))

import dtb_platdata

-def run_tests(): - """Run all the test we have for dtoc""" +def run_tests(args): + """Run all the test we have for dtoc + + Args: + args: List of positional args provided to binman. This can hold a test + name to execute (as in 'binman -t testSections', for example) + """ import test_dtoc

result = unittest.TestResult() sys.argv = [sys.argv[0]] + test_name = args and args[0] or None for module in (test_dtoc.TestDtoc,): - suite = unittest.TestLoader().loadTestsFromTestCase(module) + if test_name: + try: + suite = unittest.TestLoader().loadTestsFromName(test_name, module) + except AttributeError: + continue + else: + suite = unittest.TestLoader().loadTestsFromTestCase(module) suite.run(result)

print result @@ -68,7 +80,7 @@ parser.add_option('-t', '--test', action='store_true', dest='test',

# Run our meagre tests if options.test: - run_tests() + run_tests(args)

else: dtb_platdata.run_steps(args, options.dtb_file, options.include_disabled, diff --git a/tools/dtoc/fdt.py b/tools/dtoc/fdt.py index 7fab0cd8e90..d08b0b53e61 100644 --- a/tools/dtoc/fdt.py +++ b/tools/dtoc/fdt.py @@ -234,7 +234,6 @@ class Node: be updated. """ if self._offset != my_offset: - #print '%s: %d -> %d\n' % (self.path, self._offset, my_offset) self._offset = my_offset offset = libfdt.fdt_first_subnode(self._fdt.GetFdt(), self._offset) for subnode in self.subnodes: @@ -359,7 +358,7 @@ class Fdt: poffset = libfdt.fdt_first_property_offset(self._fdt, node._offset) while poffset >= 0: p = self._fdt_obj.get_property_by_offset(poffset) - prop = Prop(node, poffset, p.name, p.value) + prop = Prop(node, poffset, p.name, p) props_dict[prop.name] = prop

poffset = libfdt.fdt_next_property_offset(self._fdt, poffset) diff --git a/tools/dtoc/test_dtoc.py b/tools/dtoc/test_dtoc.py index 99f4e1a13a4..e475a7eb14e 100644 --- a/tools/dtoc/test_dtoc.py +++ b/tools/dtoc/test_dtoc.py @@ -4,7 +4,8 @@

"""Tests for the dtb_platdata module

-This includes unit tests for some functions and functional tests for +This includes unit tests for some functions and functional tests for the dtoc +tool. """

import collections

Add support for these functions in the Python binding. This patch stands in for a pending upstream change.

Signed-off-by: Simon Glass sjg@chromium.org ---

scripts/dtc/pylibfdt/libfdt.i_shipped | 32 +++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)

diff --git a/scripts/dtc/pylibfdt/libfdt.i_shipped b/scripts/dtc/pylibfdt/libfdt.i_shipped index 5b38e63b267..e180ee93088 100644 --- a/scripts/dtc/pylibfdt/libfdt.i_shipped +++ b/scripts/dtc/pylibfdt/libfdt.i_shipped @@ -398,6 +398,27 @@ class Fdt: return pdata return Property(pdata[0], pdata[1])

+ def get_property(self, nodeoffset, prop_name, quiet=()): + """Obtains a property by name + + Args: + nodeoffset: Offset to the node to check + prop_name: Name of property to get + quiet: Errors to ignore (empty to raise on all errors) + + Returns: + Property object, or None if not found + + Raises: + FdtException on error (e.g. invalid prop_offset or device + tree format) + """ + pdata = check_err_null( + fdt_get_property(self._fdt, nodeoffset, prop_name), quiet) + if isinstance(pdata, (int)): + return pdata + return Property(pdata[0], pdata[1]) + @staticmethod def create_empty_tree(size, quiet=()): """Create an empty device tree ready for use @@ -632,6 +653,17 @@ class Fdt: """ return check_err(fdt_node_offset_by_phandle(self._fdt, phandle), quiet)

+ def del_node(self, nodeoffset): + """Delete a node + + Args: + nodeoffset: Node offset containing property to delete + + Raises: + FdtError if the node does not exist, or another error occurs + """ + return check_err(fdt_del_node(self._fdt, nodeoffset)) +

class Property(bytearray): """Holds a device tree property name and value.

At present this module is tested via the dtoc tests. This is a bit painful since the tests are at a higher level and so failures are more difficult to diagnose.

Add some tests that exercise the fdt module directly.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/fdt.py | 12 +- tools/dtoc/test_fdt | 1 + tools/dtoc/test_fdt.py | 246 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 257 insertions(+), 2 deletions(-) create mode 120000 tools/dtoc/test_fdt create mode 100755 tools/dtoc/test_fdt.py

diff --git a/tools/dtoc/fdt.py b/tools/dtoc/fdt.py index d08b0b53e61..5cde8c125ae 100644 --- a/tools/dtoc/fdt.py +++ b/tools/dtoc/fdt.py @@ -138,6 +138,7 @@ class Prop: else: return TYPE_INT, val

+ @classmethod def GetEmpty(self, type): """Get an empty / zero value of the given type

@@ -335,12 +336,19 @@ class Fdt: """ return self._fdt

- def CheckErr(errnum, msg): + def GetFdtObj(self): + """Get the contents of the FDT + + Returns: + The FDT contents as a libfdt.Fdt object + """ + return self._fdt_obj + + def CheckErr(self, errnum, msg): if errnum: raise ValueError('Error %d: %s: %s' % (errnum, libfdt.fdt_strerror(errnum), msg))

- def GetProps(self, node): """Get all properties from a node.

diff --git a/tools/dtoc/test_fdt b/tools/dtoc/test_fdt new file mode 120000 index 00000000000..7c3b23031f0 --- /dev/null +++ b/tools/dtoc/test_fdt @@ -0,0 +1 @@ +test_fdt.py \ No newline at end of file diff --git a/tools/dtoc/test_fdt.py b/tools/dtoc/test_fdt.py new file mode 100755 index 00000000000..ba660ca9b75 --- /dev/null +++ b/tools/dtoc/test_fdt.py @@ -0,0 +1,246 @@ +#!/usr/bin/python +# SPDX-License-Identifier: GPL-2.0+ +# Copyright (c) 2018 Google, Inc +# Written by Simon Glass sjg@chromium.org +# + +from optparse import OptionParser +import glob +import os +import sys +import unittest + +# Bring in the patman libraries +our_path = os.path.dirname(os.path.realpath(__file__)) +for dirname in ['../patman', '..']: + sys.path.insert(0, os.path.join(our_path, dirname)) + +import command +import fdt +from fdt import TYPE_BYTE, TYPE_INT, TYPE_STRING, TYPE_BOOL +from fdt_util import fdt32_to_cpu +import libfdt +import test_util +import tools + +class TestFdt(unittest.TestCase): + """Tests for the Fdt module + + This includes unit tests for some functions and functional tests for the fdt + module. + """ + @classmethod + def setUpClass(cls): + tools.PrepareOutputDir(None) + + @classmethod + def tearDownClass(cls): + tools._FinaliseForTest() + + def setUp(self): + self.dtb = fdt.FdtScan('tools/dtoc/dtoc_test_simple.dts') + + def testFdt(self): + """Test that we can open an Fdt""" + self.dtb.Scan() + root = self.dtb.GetRoot() + self.assertTrue(isinstance(root, fdt.Node)) + + def testGetNode(self): + """Test the GetNode() method""" + node = self.dtb.GetNode('/spl-test') + self.assertTrue(isinstance(node, fdt.Node)) + node = self.dtb.GetNode('/i2c@0/pmic@9') + self.assertTrue(isinstance(node, fdt.Node)) + self.assertEqual('pmic@9', node.name) + + def testFlush(self): + """Check that we can flush the device tree out to its file""" + fname = self.dtb._fname + with open(fname) as fd: + data = fd.read() + os.remove(fname) + with self.assertRaises(IOError): + open(fname) + self.dtb.Flush() + with open(fname) as fd: + data = fd.read() + + def testPack(self): + """Test that packing a device tree works""" + self.dtb.Pack() + + def testGetFdt(self): + """Tetst that we can access the raw device-tree data""" + self.assertTrue(isinstance(self.dtb.GetFdt(), bytearray)) + + def testGetProps(self): + """Tests obtaining a list of properties""" + node = self.dtb.GetNode('/spl-test') + props = self.dtb.GetProps(node) + self.assertEqual(['boolval', 'bytearray', 'byteval', 'compatible', + 'intarray', 'intval', 'longbytearray', + 'stringarray', 'stringval', 'u-boot,dm-pre-reloc'], + sorted(props.keys())) + + def testCheckError(self): + """Tests the ChecKError() function""" + with self.assertRaises(ValueError) as e: + self.dtb.CheckErr(-libfdt.NOTFOUND, 'hello') + self.assertIn('FDT_ERR_NOTFOUND: hello', str(e.exception)) + + +class TestNode(unittest.TestCase): + """Test operation of the Node class""" + + @classmethod + def setUpClass(cls): + tools.PrepareOutputDir(None) + + @classmethod + def tearDownClass(cls): + tools._FinaliseForTest() + + def setUp(self): + self.dtb = fdt.FdtScan('tools/dtoc/dtoc_test_simple.dts') + self.node = self.dtb.GetNode('/spl-test') + + def testOffset(self): + """Tests that we can obtain the offset of a node""" + self.assertTrue(self.node.Offset() > 0) + + def testDelete(self): + """Tests that we can delete a property""" + node2 = self.dtb.GetNode('/spl-test2') + offset1 = node2.Offset() + self.node.DeleteProp('intval') + offset2 = node2.Offset() + self.assertTrue(offset2 < offset1) + self.node.DeleteProp('intarray') + offset3 = node2.Offset() + self.assertTrue(offset3 < offset2) + + def testFindNode(self): + """Tests that we can find a node using the _FindNode() functoin""" + node = self.dtb.GetRoot()._FindNode('i2c@0') + self.assertEqual('i2c@0', node.name) + subnode = node._FindNode('pmic@9') + self.assertEqual('pmic@9', subnode.name) + + +class TestProp(unittest.TestCase): + """Test operation of the Prop class""" + + @classmethod + def setUpClass(cls): + tools.PrepareOutputDir(None) + + @classmethod + def tearDownClass(cls): + tools._FinaliseForTest() + + def setUp(self): + self.dtb = fdt.FdtScan('tools/dtoc/dtoc_test_simple.dts') + self.node = self.dtb.GetNode('/spl-test') + self.fdt = self.dtb.GetFdtObj() + + def testGetEmpty(self): + """Tests the GetEmpty() function for the various supported types""" + self.assertEqual(True, fdt.Prop.GetEmpty(fdt.TYPE_BOOL)) + self.assertEqual(chr(0), fdt.Prop.GetEmpty(fdt.TYPE_BYTE)) + self.assertEqual(chr(0) * 4, fdt.Prop.GetEmpty(fdt.TYPE_INT)) + self.assertEqual('', fdt.Prop.GetEmpty(fdt.TYPE_STRING)) + + def testGetOffset(self): + """Test we can get the offset of a property""" + prop = self.node.props['longbytearray'] + + # Add 12, which is sizeof(struct fdt_property), to get to start of data + offset = prop.GetOffset() + 12 + data = self.dtb._fdt[offset:offset + len(prop.value)] + bytes = [chr(x) for x in data] + self.assertEqual(bytes, prop.value) + + def testWiden(self): + """Test widening of values""" + node2 = self.dtb.GetNode('/spl-test2') + prop = self.node.props['intval'] + + # No action + prop2 = node2.props['intval'] + prop.Widen(prop2) + self.assertEqual(fdt.TYPE_INT, prop.type) + self.assertEqual(1, fdt32_to_cpu(prop.value)) + + # Convert singla value to array + prop2 = self.node.props['intarray'] + prop.Widen(prop2) + self.assertEqual(fdt.TYPE_INT, prop.type) + self.assertTrue(isinstance(prop.value, list)) + + # A 4-byte array looks like a single integer. When widened by a longer + # byte array, it should turn into an array. + prop = self.node.props['longbytearray'] + prop2 = node2.props['longbytearray'] + self.assertFalse(isinstance(prop2.value, list)) + self.assertEqual(4, len(prop2.value)) + prop2.Widen(prop) + self.assertTrue(isinstance(prop2.value, list)) + self.assertEqual(9, len(prop2.value)) + + # Similarly for a string array + prop = self.node.props['stringval'] + prop2 = node2.props['stringarray'] + self.assertFalse(isinstance(prop.value, list)) + self.assertEqual(7, len(prop.value)) + prop.Widen(prop2) + self.assertTrue(isinstance(prop.value, list)) + self.assertEqual(3, len(prop.value)) + + # Enlarging an existing array + prop = self.node.props['stringarray'] + prop2 = node2.props['stringarray'] + self.assertTrue(isinstance(prop.value, list)) + self.assertEqual(2, len(prop.value)) + prop.Widen(prop2) + self.assertTrue(isinstance(prop.value, list)) + self.assertEqual(3, len(prop.value)) + + +def RunTests(args): + """Run all the test we have for the fdt model + + Args: + args: List of positional args provided to fdt. This can hold a test + name to execute (as in 'fdt -t testFdt', for example) + """ + result = unittest.TestResult() + sys.argv = [sys.argv[0]] + test_name = args and args[0] or None + for module in (TestFdt, TestNode, TestProp): + if test_name: + try: + suite = unittest.TestLoader().loadTestsFromName(test_name, module) + except AttributeError: + continue + else: + suite = unittest.TestLoader().loadTestsFromTestCase(module) + suite.run(result) + + print result + for _, err in result.errors: + print err + for _, err in result.failures: + print err + +if __name__ != '__main__': + sys.exit(1) + +parser = OptionParser() +parser.add_option('-t', '--test', action='store_true', dest='test', + default=False, help='run tests') +(options, args) = parser.parse_args() + +# Run our meagre tests +if options.test: + RunTests(args)

At present only some of the fdt functionality is tested. Add more tests to cover most things. Also turn on test coverage, which currently sits at 99%.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/test_fdt.py | 62 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+)

diff --git a/tools/dtoc/test_fdt.py b/tools/dtoc/test_fdt.py index ba660ca9b75..6dd24f74e5b 100755 --- a/tools/dtoc/test_fdt.py +++ b/tools/dtoc/test_fdt.py @@ -119,6 +119,8 @@ class TestNode(unittest.TestCase): self.node.DeleteProp('intarray') offset3 = node2.Offset() self.assertTrue(offset3 < offset2) + with self.assertRaises(ValueError): + self.node.DeleteProp('missing')

def testFindNode(self): """Tests that we can find a node using the _FindNode() functoin""" @@ -126,6 +128,7 @@ class TestNode(unittest.TestCase): self.assertEqual('i2c@0', node.name) subnode = node._FindNode('pmic@9') self.assertEqual('pmic@9', subnode.name) + self.assertEqual(None, node._FindNode('missing'))

class TestProp(unittest.TestCase): @@ -144,6 +147,53 @@ class TestProp(unittest.TestCase): self.node = self.dtb.GetNode('/spl-test') self.fdt = self.dtb.GetFdtObj()

+ def testPhandle(self): + dtb = fdt.FdtScan('tools/dtoc/dtoc_test_phandle.dts') + node = dtb.GetNode('/phandle-source') + + def _ConvertProp(self, prop_name): + """Helper function to look up a property in self.node and return it + + Args: + Property name to find + + Return fdt.Prop object for this property + """ + p = self.fdt.get_property(self.node.Offset(), prop_name) + return fdt.Prop(self.node, -1, prop_name, p) + + def testMakeProp(self): + """Test we can convert all the the types that are supported""" + prop = self._ConvertProp('boolval') + self.assertEqual(fdt.TYPE_BOOL, prop.type) + self.assertEqual(True, prop.value) + + prop = self._ConvertProp('intval') + self.assertEqual(fdt.TYPE_INT, prop.type) + self.assertEqual(1, fdt32_to_cpu(prop.value)) + + prop = self._ConvertProp('intarray') + self.assertEqual(fdt.TYPE_INT, prop.type) + val = [fdt32_to_cpu(val) for val in prop.value] + self.assertEqual([2, 3, 4], val) + + prop = self._ConvertProp('byteval') + self.assertEqual(fdt.TYPE_BYTE, prop.type) + self.assertEqual(5, ord(prop.value)) + + prop = self._ConvertProp('longbytearray') + self.assertEqual(fdt.TYPE_BYTE, prop.type) + val = [ord(val) for val in prop.value] + self.assertEqual([9, 10, 11, 12, 13, 14, 15, 16, 17], val) + + prop = self._ConvertProp('stringval') + self.assertEqual(fdt.TYPE_STRING, prop.type) + self.assertEqual('message', prop.value) + + prop = self._ConvertProp('stringarray') + self.assertEqual(fdt.TYPE_STRING, prop.type) + self.assertEqual(['multi-word', 'message'], prop.value) + def testGetEmpty(self): """Tests the GetEmpty() function for the various supported types""" self.assertEqual(True, fdt.Prop.GetEmpty(fdt.TYPE_BOOL)) @@ -207,6 +257,12 @@ class TestProp(unittest.TestCase): self.assertEqual(3, len(prop.value))

+def RunTestCoverage(): + """Run the tests and check that we get 100% coverage""" + test_util.RunTestCoverage('tools/dtoc/test_fdt.py', '/fdt.py', + ['tools/patman/*.py'], options.build_dir) + + def RunTests(args): """Run all the test we have for the fdt model

@@ -237,10 +293,16 @@ if __name__ != '__main__': sys.exit(1)

parser = OptionParser() +parser.add_option('-B', '--build-dir', type='string', default='b', + help='Directory containing the build output') parser.add_option('-t', '--test', action='store_true', dest='test', default=False, help='run tests') +parser.add_option('-T', '--test-coverage', action='store_true', + default=False, help='run tests and check for 100% coverage') (options, args) = parser.parse_args()

# Run our meagre tests if options.test: RunTests(args) +elif options.test_coverage: + RunTestCoverage()

At present the Fdt class has its own copy of the device tree. This is confusing an unnecessary now that pylibfdt has its own. Drop it and provide access functions to the buffer.

This allows us to move the rest of the implementation to use pylibfdt methods instead of directly calling libfdt stubs.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/fdt.py | 16 ++++++++-------- tools/dtoc/test_fdt.py | 6 +++--- 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/tools/dtoc/fdt.py b/tools/dtoc/fdt.py index 18cde2604ff..e24acf12804 100644 --- a/tools/dtoc/fdt.py +++ b/tools/dtoc/fdt.py @@ -235,12 +235,13 @@ class Node: Note: This does not take account of property offsets - these will not be updated. """ + fdt_obj = self._fdt._fdt_obj if self._offset != my_offset: self._offset = my_offset - offset = libfdt.fdt_first_subnode(self._fdt.GetFdt(), self._offset) + offset = fdt_obj.first_subnode(self._offset, QUIET_NOTFOUND) for subnode in self.subnodes: subnode.Refresh(offset) - offset = libfdt.fdt_next_subnode(self._fdt.GetFdt(), offset) + offset = fdt_obj.next_subnode(offset, QUIET_NOTFOUND)

def DeleteProp(self, prop_name): """Delete a property of a node @@ -252,7 +253,7 @@ class Node: Raises: ValueError if the property does not exist """ - CheckErr(libfdt.fdt_delprop(self._fdt.GetFdt(), self.Offset(), prop_name), + CheckErr(self._fdt._fdt_obj.delprop(self.Offset(), prop_name), "Node '%s': delete property: '%s'" % (self.path, prop_name)) del self.props[prop_name] self._fdt.Invalidate() @@ -272,8 +273,7 @@ class Fdt: self._fname = fdt_util.EnsureCompiled(self._fname)

with open(self._fname) as fd: - self._fdt = bytearray(fd.read()) - self._fdt_obj = libfdt.Fdt(self._fdt) + self._fdt_obj = libfdt.Fdt(fd.read())

def Scan(self, root='/'): """Scan a device tree, building up a tree of Node objects @@ -317,7 +317,7 @@ class Fdt: If the device tree has changed in memory, write it back to the file. """ with open(self._fname, 'wb') as fd: - fd.write(self._fdt) + fd.write(self._fdt_obj.as_bytearray())

def Pack(self): """Pack the device tree down to its minimum size @@ -328,13 +328,13 @@ class Fdt: CheckErr(self._fdt_obj.pack(), 'pack') self.Invalidate()

- def GetFdt(self): + def GetContents(self): """Get the contents of the FDT

Returns: The FDT contents as a string of bytes """ - return self._fdt + return self._fdt_obj.as_bytearray()

def GetFdtObj(self): """Get the contents of the FDT diff --git a/tools/dtoc/test_fdt.py b/tools/dtoc/test_fdt.py index 6dd24f74e5b..ba95a4b77de 100755 --- a/tools/dtoc/test_fdt.py +++ b/tools/dtoc/test_fdt.py @@ -72,7 +72,7 @@ class TestFdt(unittest.TestCase):

def testGetFdt(self): """Tetst that we can access the raw device-tree data""" - self.assertTrue(isinstance(self.dtb.GetFdt(), bytearray)) + self.assertTrue(isinstance(self.dtb.GetContents(), bytearray))

def testGetProps(self): """Tests obtaining a list of properties""" @@ -119,7 +119,7 @@ class TestNode(unittest.TestCase): self.node.DeleteProp('intarray') offset3 = node2.Offset() self.assertTrue(offset3 < offset2) - with self.assertRaises(ValueError): + with self.assertRaises(libfdt.FdtException): self.node.DeleteProp('missing')

def testFindNode(self): @@ -207,7 +207,7 @@ class TestProp(unittest.TestCase):

# Add 12, which is sizeof(struct fdt_property), to get to start of data offset = prop.GetOffset() + 12 - data = self.dtb._fdt[offset:offset + len(prop.value)] + data = self.dtb.GetContents()[offset:offset + len(prop.value)] bytes = [chr(x) for x in data] self.assertEqual(bytes, prop.value)

At present the algortihm is not correct since it will return the root node if the requested node is not found and there are no slashes in the requested node name. Fix this and add a test.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/fdt.py | 5 ++++- tools/dtoc/test_fdt.py | 4 ++++ 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/tools/dtoc/fdt.py b/tools/dtoc/fdt.py index 2d7b6328f11..fc8aeb81de5 100644 --- a/tools/dtoc/fdt.py +++ b/tools/dtoc/fdt.py @@ -324,7 +324,10 @@ class Fdt: Node object, or None if not found """ node = self._root - for part in path.split('/')[1:]: + parts = path.split('/') + if len(parts) < 2: + return None + for part in parts[1:]: node = node._FindNode(part) if not node: return None diff --git a/tools/dtoc/test_fdt.py b/tools/dtoc/test_fdt.py index cd86144896f..78afb33b056 100755 --- a/tools/dtoc/test_fdt.py +++ b/tools/dtoc/test_fdt.py @@ -77,6 +77,7 @@ class TestFdt(unittest.TestCase): node = self.dtb.GetNode('/i2c@0/pmic@9') self.assertTrue(isinstance(node, fdt.Node)) self.assertEqual('pmic@9', node.name) + self.assertEqual(None, self.dtb.GetNode('/i2c@0/pmic@9/missing'))

def testFlush(self): """Check that we can flush the device tree out to its file""" @@ -177,6 +178,9 @@ class TestProp(unittest.TestCase): self.node = self.dtb.GetNode('/spl-test') self.fdt = self.dtb.GetFdtObj()

+ def testMissingNode(self): + self.assertEqual(None, self.dtb.GetNode('missing')) + def testPhandle(self): dtb = fdt.FdtScan('tools/dtoc/dtoc_test_phandle.dts') node = dtb.GetNode('/phandle-source')

At present a property with a single phandle looks like an integer value to dtoc. Correct this by adjusting it in the phandle-processing code.

Add a test for this, so that code coverage increases to 100%.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/dtb_platdata.py | 12 ++++++++---- tools/dtoc/dtoc_test_phandle.dts | 6 ++++++ tools/dtoc/test_dtoc.py | 10 ++++++++++ tools/dtoc/test_fdt.py | 4 +++- 4 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/tools/dtoc/dtb_platdata.py b/tools/dtoc/dtb_platdata.py index 2f7302e5295..b1323aef198 100644 --- a/tools/dtoc/dtb_platdata.py +++ b/tools/dtoc/dtb_platdata.py @@ -211,15 +211,21 @@ class DtbPlatdata(object): Number of argument cells is this is a phandle, else None """ if prop.name in ['clocks']: + if not isinstance(prop.value, list): + prop.value = [prop.value] val = prop.value - if not isinstance(val, list): - val = [val] i = 0

max_args = 0 args = [] while i < len(val): phandle = fdt_util.fdt32_to_cpu(val[i]) + # If we get to the end of the list, stop. This can happen + # since some nodes have more phandles in the list than others, + # but we allocate enough space for the largest list. So those + # nodes with shorter lists end up with zeroes at the end. + if not phandle: + break target = self._fdt.phandle_to_node.get(phandle) if not target: raise ValueError("Cannot parse '%s' in node '%s'" % @@ -400,8 +406,6 @@ class DtbPlatdata(object): continue info = self.get_phandle_argc(prop, node.name) if info: - if not isinstance(prop.value, list): - prop.value = [prop.value] # Process the list as pairs of (phandle, id) pos = 0 for args in info.args: diff --git a/tools/dtoc/dtoc_test_phandle.dts b/tools/dtoc/dtoc_test_phandle.dts index 91dfec5c63f..a71acffc698 100644 --- a/tools/dtoc/dtoc_test_phandle.dts +++ b/tools/dtoc/dtoc_test_phandle.dts @@ -33,4 +33,10 @@ compatible = "source"; clocks = <&phandle &phandle_1 11 &phandle_2 12 13 &phandle>; }; + + phandle-source2 { + u-boot,dm-pre-reloc; + compatible = "source"; + clocks = <&phandle>; + }; }; diff --git a/tools/dtoc/test_dtoc.py b/tools/dtoc/test_dtoc.py index 95818928b32..41a4c53bb9d 100644 --- a/tools/dtoc/test_dtoc.py +++ b/tools/dtoc/test_dtoc.py @@ -324,6 +324,16 @@ U_BOOT_DEVICE(phandle_source) = { \t.platdata_size\t= sizeof(dtv_phandle_source), };

+static struct dtd_source dtv_phandle_source2 = { +\t.clocks\t\t\t= { +\t\t\t{&dtv_phandle_target, {}},}, +}; +U_BOOT_DEVICE(phandle_source2) = { +\t.name\t\t= "source", +\t.platdata\t= &dtv_phandle_source2, +\t.platdata_size\t= sizeof(dtv_phandle_source2), +}; + ''', data)

def test_aliases(self): diff --git a/tools/dtoc/test_fdt.py b/tools/dtoc/test_fdt.py index d6ea1951001..97b8cbb794e 100755 --- a/tools/dtoc/test_fdt.py +++ b/tools/dtoc/test_fdt.py @@ -209,7 +209,9 @@ class TestProp(unittest.TestCase):

def testPhandle(self): dtb = fdt.FdtScan('tools/dtoc/dtoc_test_phandle.dts') - node = dtb.GetNode('/phandle-source') + node = dtb.GetNode('/phandle-source2') + prop = node.props['clocks'] + self.assertTrue(prop.GetPhandle() > 0)

def _ConvertProp(self, prop_name): """Helper function to look up a property in self.node and return it

Add a -T option to run a code-coverage test on dtoc. At present this is about 96%. Future work will increase it to 100%.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/dtoc.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+)

diff --git a/tools/dtoc/dtoc.py b/tools/dtoc/dtoc.py index 2e6a4db8bc1..1fbc2db6e46 100755 --- a/tools/dtoc/dtoc.py +++ b/tools/dtoc/dtoc.py @@ -35,6 +35,7 @@ our_path = os.path.dirname(os.path.realpath(__file__)) sys.path.append(os.path.join(our_path, '../patman'))

import dtb_platdata +import test_util

def run_tests(args): """Run all the test we have for dtoc @@ -64,10 +65,19 @@ def run_tests(args): for _, err in result.failures: print err

+def RunTestCoverage(): + """Run the tests and check that we get 100% coverage""" + sys.argv = [sys.argv[0]] + test_util.RunTestCoverage('tools/dtoc/dtoc.py', '/dtb_platdata.py', + ['tools/patman/*.py'], options.build_dir) + + if __name__ != '__main__': sys.exit(1)

parser = OptionParser() +parser.add_option('-B', '--build-dir', type='string', default='b', + help='Directory containing the build output') parser.add_option('-d', '--dtb-file', action='store', help='Specify the .dtb input file') parser.add_option('--include-disabled', action='store_true', @@ -76,12 +86,17 @@ parser.add_option('-o', '--output', action='store', default='-', help='Select output filename') parser.add_option('-t', '--test', action='store_true', dest='test', default=False, help='run tests') +parser.add_option('-T', '--test-coverage', action='store_true', + default=False, help='run tests and check for 100% coverage') (options, args) = parser.parse_args()

# Run our meagre tests if options.test: run_tests(args)

+elif options.test_coverage: + RunTestCoverage() + else: dtb_platdata.run_steps(args, options.dtb_file, options.include_disabled, options.output)

This function is useful in various tests. Move it into the common test utility module.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/elf_test.py | 22 ++-------------------- tools/binman/image_test.py | 2 +- tools/patman/test_util.py | 22 ++++++++++++++++++++++ 3 files changed, 25 insertions(+), 21 deletions(-)

diff --git a/tools/binman/elf_test.py b/tools/binman/elf_test.py index fb6e451cf0e..9c8f1feca85 100644 --- a/tools/binman/elf_test.py +++ b/tools/binman/elf_test.py @@ -4,33 +4,15 @@ # # Test for the elf module

-from contextlib import contextmanager import os import sys import unittest

-try: - from StringIO import StringIO -except ImportError: - from io import StringIO - import elf +import test_util

binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))

-# Use this to suppress stdout/stderr output: -# with capture_sys_output() as (stdout, stderr) -# ...do something... -@contextmanager -def capture_sys_output(): - capture_out, capture_err = StringIO(), StringIO() - old_out, old_err = sys.stdout, sys.stderr - try: - sys.stdout, sys.stderr = capture_out, capture_err - yield capture_out, capture_err - finally: - sys.stdout, sys.stderr = old_out, old_err -

class FakeEntry: def __init__(self, contents_size): @@ -110,7 +92,7 @@ class TestElf(unittest.TestCase): entry = FakeEntry(20) section = FakeSection() elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms') - with capture_sys_output() as (stdout, stderr): + with test_util.capture_sys_output() as (stdout, stderr): syms = elf.LookupAndWriteSymbols(elf_fname, entry, section) elf.debug = False self.assertTrue(len(stdout.getvalue()) > 0) diff --git a/tools/binman/image_test.py b/tools/binman/image_test.py index 45dd2378c8a..3775e1afb07 100644 --- a/tools/binman/image_test.py +++ b/tools/binman/image_test.py @@ -7,7 +7,7 @@ import unittest

from image import Image -from elf_test import capture_sys_output +from test_util import capture_sys_output

class TestImage(unittest.TestCase): def testInvalidFormat(self): diff --git a/tools/patman/test_util.py b/tools/patman/test_util.py index a240f383777..d159509e812 100644 --- a/tools/patman/test_util.py +++ b/tools/patman/test_util.py @@ -3,12 +3,19 @@ # Copyright (c) 2016 Google, Inc #

+from contextlib import contextmanager import glob import os import sys

import command

+try: + from StringIO import StringIO +except ImportError: + from io import StringIO + + def RunTestCoverage(prog, filter_fname, exclude_list, build_dir): """Run tests and check that we get 100% coverage

@@ -49,3 +56,18 @@ def RunTestCoverage(prog, filter_fname, exclude_list, build_dir): ok = False if not ok: raise ValueError('Test coverage failure') + + +# Use this to suppress stdout/stderr output: +# with capture_sys_output() as (stdout, stderr) +# ...do something... +@contextmanager +def capture_sys_output(): + capture_out, capture_err = StringIO(), StringIO() + old_out, old_err = sys.stdout, sys.stderr + try: + sys.stdout, sys.stderr = capture_out, capture_err + yield capture_out, capture_err + finally: + sys.stdout, sys.stderr = old_out, old_err +

Add a few simple functions to add a placeholder integer property, and set its value.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/fdt.py | 27 +++++++++++++++++++++++++++ tools/dtoc/test_fdt.py | 20 ++++++++++++++++++++ 2 files changed, 47 insertions(+)

diff --git a/tools/dtoc/fdt.py b/tools/dtoc/fdt.py index f11fb75b1a4..7282b7e021c 100644 --- a/tools/dtoc/fdt.py +++ b/tools/dtoc/fdt.py @@ -277,6 +277,33 @@ class Node: del self.props[prop_name] self._fdt.Invalidate()

+ def AddZeroProp(self, prop_name): + """Add a new property to the device tree with an integer value of 0. + + Args: + prop_name: Name of property + """ + fdt_obj = self._fdt._fdt_obj + if fdt_obj.setprop_u32(self.Offset(), prop_name, 0, + (libfdt.NOSPACE,)) == -libfdt.NOSPACE: + fdt_obj.open_into(fdt_obj.totalsize() + 1024) + fdt_obj.setprop_u32(self.Offset(), prop_name, 0) + self.props[prop_name] = Prop(self, -1, prop_name, '\0' * 4) + self._fdt.Invalidate() + + def SetInt(self, prop_name, val): + """Update an integer property int the device tree. + + This is not allowed to change the size of the FDT. + + Args: + prop_name: Name of property + val: Value to set + """ + fdt_obj = self._fdt._fdt_obj + fdt_obj.setprop_u32(self.Offset(), prop_name, val) + + class Fdt: """Provides simple access to a flat device tree blob using libfdts.

diff --git a/tools/dtoc/test_fdt.py b/tools/dtoc/test_fdt.py index 97b8cbb794e..0bc4bd64646 100755 --- a/tools/dtoc/test_fdt.py +++ b/tools/dtoc/test_fdt.py @@ -318,6 +318,26 @@ class TestProp(unittest.TestCase): self.assertTrue(isinstance(prop.value, list)) self.assertEqual(3, len(prop.value))

+ def testAdd(self): + """Test adding properties""" + self.fdt.pack() + # This function should automatically expand the device tree + self.node.AddZeroProp('one') + self.node.AddZeroProp('two') + self.node.AddZeroProp('three') + + # Updating existing properties should be OK, since the device-tree size + # does not change + self.fdt.pack() + self.node.SetInt('one', 1) + self.node.SetInt('two', 2) + self.node.SetInt('three', 3) + + # This should fail since it would need to increase the device-tree size + with self.assertRaises(libfdt.FdtException) as e: + self.node.SetInt('four', 4) + self.assertIn('FDT_ERR_NOSPACE', str(e.exception)) +

def RunTestCoverage(): """Run the tests and check that we get 100% coverage"""

Some entry types modify the device tree, e.g. to remove microcode or add a property. So far this just modifies their local copy and does not affect a 'shared' device tree.

Rather than doing this modification in the ObtainContents() method, and a new ProcessFdt() method which is specifically designed to modify this shared device tree.

Move the existing device-tree code over to use this method, reducing ObtainContents() to the goal of just obtaining the contents without any processing, even for device tree.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/README | 23 +++++---- tools/binman/bsection.py | 15 ++++++ tools/binman/control.py | 52 ++++++++++++++++++++- tools/binman/entry.py | 3 ++ tools/binman/etype/section.py | 3 ++ tools/binman/etype/u_boot_dtb_with_ucode.py | 47 ++++++++++--------- tools/binman/etype/u_boot_ucode.py | 2 +- tools/binman/etype/u_boot_with_ucode_ptr.py | 7 ++- tools/binman/image.py | 3 ++ 9 files changed, 118 insertions(+), 37 deletions(-)

diff --git a/tools/binman/README b/tools/binman/README index 3cfcf84d92c..008d5750528 100644 --- a/tools/binman/README +++ b/tools/binman/README @@ -462,7 +462,14 @@ Order of image creation

Image creation proceeds in the following order, for each entry in the image.

-1. GetEntryContents() - the contents of each entry are obtained, normally by +1. ProcessFdt() - process the device tree information as required by the +particular entry. This may involve adding or deleting properties. If the +processing is complete, this method should return True. If the processing +cannot complete because it needs the ProcessFdt() method of another entry to +run first, this method should return False, in which case it will be called +again later. + +2. GetEntryContents() - the contents of each entry are obtained, normally by reading from a file. This calls the Entry.ObtainContents() to read the contents. The default version of Entry.ObtainContents() calls Entry.GetDefaultFilename() and then reads that file. So a common mechanism @@ -471,35 +478,35 @@ functions must return True when they have read the contents. Binman will retry calling the functions a few times if False is returned, allowing dependencies between the contents of different entries.

-2. GetEntryPositions() - calls Entry.GetPositions() for each entry. This can +3. GetEntryPositions() - calls Entry.GetPositions() for each entry. This can return a dict containing entries that need updating. The key should be the entry name and the value is a tuple (pos, size). This allows an entry to provide the position and size for other entries. The default implementation of GetEntryPositions() returns {}.

-3. PackEntries() - calls Entry.Pack() which figures out the position and +4. PackEntries() - calls Entry.Pack() which figures out the position and size of an entry. The 'current' image position is passed in, and the function returns the position immediately after the entry being packed. The default implementation of Pack() is usually sufficient.

-4. CheckSize() - checks that the contents of all the entries fits within +5. CheckSize() - checks that the contents of all the entries fits within the image size. If the image does not have a defined size, the size is set large enough to hold all the entries.

-5. CheckEntries() - checks that the entries do not overlap, nor extend +6. CheckEntries() - checks that the entries do not overlap, nor extend outside the image.

-6. ProcessEntryContents() - this calls Entry.ProcessContents() on each entry. +7. ProcessEntryContents() - this calls Entry.ProcessContents() on each entry. The default implementatoin does nothing. This can be overriden to adjust the contents of an entry in some way. For example, it would be possible to create an entry containing a hash of the contents of some other entries. At this stage the position and size of entries should not be adjusted.

-7. WriteSymbols() - write the value of symbols into the U-Boot SPL binary. +8. WriteSymbols() - write the value of symbols into the U-Boot SPL binary. See 'Access to binman entry positions at run time' below for a description of what happens in this stage.

-8. BuildImage() - builds the image and writes it to a file. This is the final +9. BuildImage() - builds the image and writes it to a file. This is the final step.

diff --git a/tools/binman/bsection.py b/tools/binman/bsection.py index 06a6711350a..3ed361d69a2 100644 --- a/tools/binman/bsection.py +++ b/tools/binman/bsection.py @@ -90,6 +90,21 @@ class Section(object): entry.SetPrefix(self._name_prefix) self._entries[node.name] = entry

+ def ProcessFdt(self, fdt): + todo = self._entries.values() + for passnum in range(3): + next_todo = [] + for entry in todo: + if not entry.ProcessFdt(fdt): + next_todo.append(entry) + todo = next_todo + if not todo: + break + if todo: + self._Raise('Internal error: Could not complete processing of Fdt: ' + 'remaining %s' % todo) + return True + def CheckSize(self): """Check that the section contents does not exceed its size, etc.""" contents_size = 0 diff --git a/tools/binman/control.py b/tools/binman/control.py index 92434729061..5325a6a0066 100644 --- a/tools/binman/control.py +++ b/tools/binman/control.py @@ -21,6 +21,11 @@ import tout # Make this global so that it can be referenced from tests images = OrderedDict()

+# Records the device-tree files known to binman, keyed by filename (e.g. +# 'u-boot-spl.dtb') +fdt_files = {} + + def _ReadImageDesc(binman_node): """Read the image descriptions from the /binman node

@@ -53,6 +58,24 @@ def _FindBinmanNode(dtb): return node return None

+def GetFdt(fname): + """Get the Fdt object for a particular device-tree filename + + Binman keeps track of at least one device-tree file called u-boot.dtb but + can also have others (e.g. for SPL). This function looks up the given + filename and returns the associated Fdt object. + + Args: + fname: Filename to look up (e.g. 'u-boot.dtb'). + + Returns: + Fdt object associated with the filename + """ + return fdt_files[fname] + +def GetFdtPath(fname): + return fdt_files[fname]._fname + def Binman(options, args): """The main control code for binman

@@ -93,12 +116,39 @@ def Binman(options, args): try: tools.SetInputDirs(options.indir) tools.PrepareOutputDir(options.outdir, options.preserve) - dtb = fdt.FdtScan(dtb_fname) + + # Get the device tree ready by compiling it and copying the compiled + # output into a file in our output directly. Then scan it for use + # in binman. + dtb_fname = fdt_util.EnsureCompiled(dtb_fname) + fname = tools.GetOutputFilename('u-boot-out.dtb') + with open(dtb_fname) as infd: + with open(fname, 'wb') as outfd: + outfd.write(infd.read()) + dtb = fdt.FdtScan(fname) + + # Note the file so that GetFdt() can find it + fdt_files['u-boot.dtb'] = dtb node = _FindBinmanNode(dtb) if not node: raise ValueError("Device tree '%s' does not have a 'binman' " "node" % dtb_fname) + images = _ReadImageDesc(node) + + # Prepare the device tree by making sure that any missing + # properties are added (e.g. 'pos' and 'size'). The values of these + # may not be correct yet, but we add placeholders so that the + # size of the device tree is correct. Later, in + # SetCalculatedProperties() we will insert the correct values + # without changing the device-tree size, thus ensuring that our + # entry positions remain the same. + for image in images.values(): + image.ProcessFdt(dtb) + + dtb.Pack() + dtb.Flush() + for image in images.values(): # Perform all steps for this image, including checking and # writing it. This means that errors found with a later diff --git a/tools/binman/entry.py b/tools/binman/entry.py index 303c992e375..62e65c91266 100644 --- a/tools/binman/entry.py +++ b/tools/binman/entry.py @@ -130,6 +130,9 @@ class Entry(object): self.align_end = fdt_util.GetInt(self._node, 'align-end') self.pos_unset = fdt_util.GetBool(self._node, 'pos-unset')

+ def ProcessFdt(self, fdt): + return True + def SetPrefix(self, prefix): """Set the name prefix for a node

diff --git a/tools/binman/etype/section.py b/tools/binman/etype/section.py index 36b31a849f8..9b38738d38d 100644 --- a/tools/binman/etype/section.py +++ b/tools/binman/etype/section.py @@ -17,6 +17,9 @@ class Entry_section(Entry): Entry.__init__(self, image, etype, node) self._section = bsection.Section(node.name, node)

+ def ProcessFdt(self, fdt): + return self._section.ProcessFdt(fdt) + def ObtainContents(self): return self._section.GetEntryContents()

diff --git a/tools/binman/etype/u_boot_dtb_with_ucode.py b/tools/binman/etype/u_boot_dtb_with_ucode.py index 1e530d6570a..54c2298bc2e 100644 --- a/tools/binman/etype/u_boot_dtb_with_ucode.py +++ b/tools/binman/etype/u_boot_dtb_with_ucode.py @@ -5,6 +5,7 @@ # Entry-type module for U-Boot device tree with the microcode removed #

+import control import fdt from entry import Entry from blob import Entry_blob @@ -22,13 +23,13 @@ class Entry_u_boot_dtb_with_ucode(Entry_blob): self.collate = False self.ucode_offset = None self.ucode_size = None + self.ucode = None + self.ready = False

def GetDefaultFilename(self): return 'u-boot.dtb'

- def ObtainContents(self): - Entry_blob.ObtainContents(self) - + def ProcessFdt(self, fdt): # If the section does not need microcode, there is nothing to do ucode_dest_entry = self.section.FindEntryType( 'u-boot-spl-with-ucode-ptr') @@ -38,36 +39,36 @@ class Entry_u_boot_dtb_with_ucode(Entry_blob): if not ucode_dest_entry or not ucode_dest_entry.target_pos: return True

- # Create a new file to hold the copied device tree - dtb_name = 'u-boot-dtb-with-ucode.dtb' - fname = tools.GetOutputFilename(dtb_name) - with open(fname, 'wb') as fd: - fd.write(self.data) - # Remove the microcode - dtb = fdt.FdtScan(fname) - ucode = dtb.GetNode('/microcode') - if not ucode: + fname = self.GetDefaultFilename() + fdt = control.GetFdt(fname) + self.ucode = fdt.GetNode('/microcode') + if not self.ucode: raise self.Raise("No /microcode node found in '%s'" % fname)

# There's no need to collate it (move all microcode into one place) # if we only have one chunk of microcode. - self.collate = len(ucode.subnodes) > 1 - for node in ucode.subnodes: + self.collate = len(self.ucode.subnodes) > 1 + for node in self.ucode.subnodes: data_prop = node.props.get('data') if data_prop: self.ucode_data += ''.join(data_prop.bytes) if self.collate: - prop = node.DeleteProp('data') - else: + node.DeleteProp('data') + return True + + def ObtainContents(self): + # Call the base class just in case it does something important. + Entry_blob.ObtainContents(self) + self._pathname = control.GetFdtPath(self._filename) + self.ReadContents() + if self.ucode: + for node in self.ucode.subnodes: + data_prop = node.props.get('data') + if data_prop and not self.collate: # Find the offset in the device tree of the ucode data self.ucode_offset = data_prop.GetOffset() + 12 self.ucode_size = len(data_prop.bytes) - if self.collate: - dtb.Pack() - dtb.Flush() - - # Make this file the contents of this entry - self._pathname = fname - self.ReadContents() + self.ready = True return True + diff --git a/tools/binman/etype/u_boot_ucode.py b/tools/binman/etype/u_boot_ucode.py index 8cae7deed3c..ea0c85cc5c7 100644 --- a/tools/binman/etype/u_boot_ucode.py +++ b/tools/binman/etype/u_boot_ucode.py @@ -71,7 +71,7 @@ class Entry_u_boot_ucode(Entry_blob): fdt_entry = self.section.FindEntryType('u-boot-dtb-with-ucode') if not fdt_entry: return True - if not fdt_entry.ucode_data: + if not fdt_entry.ready: return False

if not fdt_entry.collate: diff --git a/tools/binman/etype/u_boot_with_ucode_ptr.py b/tools/binman/etype/u_boot_with_ucode_ptr.py index 86945f33184..8b1e41152e3 100644 --- a/tools/binman/etype/u_boot_with_ucode_ptr.py +++ b/tools/binman/etype/u_boot_with_ucode_ptr.py @@ -28,7 +28,7 @@ class Entry_u_boot_with_ucode_ptr(Entry_blob): def GetDefaultFilename(self): return 'u-boot-nodtb.bin'

- def ObtainContents(self): + def ProcessFdt(self, fdt): # Figure out where to put the microcode pointer fname = tools.GetInputFilename(self.elf_fname) sym = elf.GetSymbolAddress(fname, '_dt_ucode_base_size') @@ -36,8 +36,7 @@ class Entry_u_boot_with_ucode_ptr(Entry_blob): self.target_pos = sym elif not fdt_util.GetBool(self._node, 'optional-ucode'): self.Raise('Cannot locate _dt_ucode_base_size symbol in u-boot') - - return Entry_blob.ObtainContents(self) + return True

def ProcessContents(self): # If the image does not need microcode, there is nothing to do @@ -73,7 +72,7 @@ class Entry_u_boot_with_ucode_ptr(Entry_blob): pos, size = ucode_entry.pos, ucode_entry.size else: dtb_entry = self.section.FindEntryType('u-boot-dtb-with-ucode') - if not dtb_entry: + if not dtb_entry or not dtb_entry.ready: self.Raise('Cannot find microcode region u-boot-dtb-with-ucode') pos = dtb_entry.pos + dtb_entry.ucode_offset size = dtb_entry.ucode_size diff --git a/tools/binman/image.py b/tools/binman/image.py index 835b66c99f5..9732493709c 100644 --- a/tools/binman/image.py +++ b/tools/binman/image.py @@ -54,6 +54,9 @@ class Image: self._filename = filename self._section = bsection.Section('main-section', self._node)

+ def ProcessFdt(self, fdt): + return self._section.ProcessFdt(fdt) + def GetEntryContents(self): """Call ObtainContents() for the section """

It is useful to write the position and size of each entry back to the device tree so that U-Boot can access this at runtime. Add a feature to support this, along with associated tests.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/README | 6 +-- tools/binman/control.py | 2 + tools/binman/ftest.py | 69 ++++++++++++++++++++++++----- tools/binman/test/60_fdt_update.dts | 28 ++++++++++++ 4 files changed, 91 insertions(+), 14 deletions(-) create mode 100644 tools/binman/test/60_fdt_update.dts

diff --git a/tools/binman/README b/tools/binman/README index 8b598a75c80..207928aa955 100644 --- a/tools/binman/README +++ b/tools/binman/README @@ -669,13 +669,11 @@ To do -----

Some ideas: -- Fill out the device tree to include the final position and size of each - entry (since the input file may not always specify these). See also - 'Access to binman entry positions at run time' above - Use of-platdata to make the information available to code that is unable to use device tree (such as a very small SPL image) - Allow easy building of images by specifying just the board name -- Produce a full Python binding for libfdt (for upstream) +- Produce a full Python binding for libfdt (for upstream). This is nearing + completion but some work remains - Add an option to decode an image into the constituent binaries - Support building an image for a board (-b) more completely, with a configurable build directory diff --git a/tools/binman/control.py b/tools/binman/control.py index eafabf05c7c..a40b300fdac 100644 --- a/tools/binman/control.py +++ b/tools/binman/control.py @@ -168,6 +168,8 @@ def Binman(options, args): image.BuildImage() if options.map: image.WriteMap() + with open(fname, 'wb') as outfd: + outfd.write(dtb.GetContents()) finally: tools.FinaliseOutputDir() finally: diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index af3b4dc3e56..b49b1b9b734 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -146,19 +146,23 @@ class TestFunctional(unittest.TestCase): # options.verbosity = tout.DEBUG return control.Binman(options, args)

- def _DoTestFile(self, fname, debug=False, map=False): + def _DoTestFile(self, fname, debug=False, map=False, update_dtb=False): """Run binman with a given test file

Args: fname: Device-tree source filename to use (e.g. 05_simple.dts) debug: True to enable debugging output map: True to output map files for the images + update_dtb: Update the position and size of each entry in the device + tree before packing it into the image """ args = ['-p', '-I', self._indir, '-d', self.TestFile(fname)] if debug: args.append('-D') if map: args.append('-m') + if update_dtb: + args.append('-up') return self._DoBinman(*args)

def _SetupDtb(self, fname, outfile='u-boot.dtb'): @@ -183,7 +187,8 @@ class TestFunctional(unittest.TestCase): TestFunctional._MakeInputFile(outfile, data) return data

- def _DoReadFileDtb(self, fname, use_real_dtb=False, map=False): + def _DoReadFileDtb(self, fname, use_real_dtb=False, map=False, + update_dtb=False): """Run binman and return the resulting image

This runs binman with a given test file and then reads the resulting @@ -199,6 +204,8 @@ class TestFunctional(unittest.TestCase): test contents (the U_BOOT_DTB_DATA string) can be used. But in some test we need the real contents. map: True to output map files for the images + update_dtb: Update the position and size of each entry in the device + tree before packing it into the image

Returns: Tuple: @@ -212,21 +219,22 @@ class TestFunctional(unittest.TestCase): dtb_data = self._SetupDtb(fname)

try: - retcode = self._DoTestFile(fname, map=map) + retcode = self._DoTestFile(fname, map=map, update_dtb=update_dtb) self.assertEqual(0, retcode) + out_dtb_fname = control.GetFdtPath('u-boot.dtb')

# Find the (only) image, read it and return its contents image = control.images['image'] - fname = tools.GetOutputFilename('image.bin') - self.assertTrue(os.path.exists(fname)) + image_fname = tools.GetOutputFilename('image.bin') + self.assertTrue(os.path.exists(image_fname)) if map: map_fname = tools.GetOutputFilename('image.map') with open(map_fname) as fd: map_data = fd.read() else: map_data = None - with open(fname) as fd: - return fd.read(), dtb_data, map_data + with open(image_fname) as fd: + return fd.read(), dtb_data, map_data, out_dtb_fname finally: # Put the test file back if use_real_dtb: @@ -300,6 +308,26 @@ class TestFunctional(unittest.TestCase): """ return struct.unpack('>L', dtb[4:8])[0]

+ def _GetPropTree(self, dtb_data, node_names): + def AddNode(node, path): + if node.name != '/': + path += '/' + node.name + #print 'path', path + for subnode in node.subnodes: + for prop in subnode.props.values(): + if prop.name in node_names: + prop_path = path + '/' + subnode.name + ':' + prop.name + tree[prop_path[len('/binman/'):]] = fdt_util.fdt32_to_cpu( + prop.value) + #print ' ', prop.name + AddNode(subnode, path) + + tree = {} + dtb = fdt.Fdt(dtb_data) + dtb.Scan() + AddNode(dtb.GetRoot(), '') + return tree + def testRun(self): """Test a basic run with valid args""" result = self._RunBinman('-h') @@ -845,7 +873,7 @@ class TestFunctional(unittest.TestCase): """Test that we can cope with an image without microcode (e.g. qemu)""" with open(self.TestFile('u_boot_no_ucode_ptr')) as fd: TestFunctional._MakeInputFile('u-boot', fd.read()) - data, dtb, _ = self._DoReadFileDtb('44_x86_optional_ucode.dts', True) + data, dtb, _, _ = self._DoReadFileDtb('44_x86_optional_ucode.dts', True)

# Now check the device tree has no microcode self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)]) @@ -980,7 +1008,7 @@ class TestFunctional(unittest.TestCase):

def testMap(self): """Tests outputting a map of the images""" - _, _, map_data = self._DoReadFileDtb('55_sections.dts', map=True) + _, _, map_data, _ = self._DoReadFileDtb('55_sections.dts', map=True) self.assertEqual('''Position Size Name 00000000 00000010 section@0 00000000 00000004 u-boot @@ -990,7 +1018,7 @@ class TestFunctional(unittest.TestCase):

def testNamePrefix(self): """Tests that name prefixes are used""" - _, _, map_data = self._DoReadFileDtb('56_name_prefix.dts', map=True) + _, _, map_data, _ = self._DoReadFileDtb('56_name_prefix.dts', map=True) self.assertEqual('''Position Size Name 00000000 00000010 section@0 00000000 00000004 ro-u-boot @@ -1013,6 +1041,27 @@ class TestFunctional(unittest.TestCase): self.assertIn("Node '/binman/_testing': Cannot update entry size from " '2 to 1', str(e.exception))

+ def testUpdateFdt(self): + """Test that we can update the device tree with pos/size info""" + _, _, _, out_dtb_fname = self._DoReadFileDtb('60_fdt_update.dts', + update_dtb=True) + props = self._GetPropTree(out_dtb_fname, ['pos', 'size']) + with open('/tmp/x.dtb', 'wb') as outf: + with open(out_dtb_fname) as inf: + outf.write(inf.read()) + self.assertEqual({ + 'section@0/u-boot:pos': 0, + 'section@0/u-boot:size': len(U_BOOT_DATA), + 'section@0:pos': 0, + 'section@0:size': 16, + + 'section@1/u-boot:pos': 0, + 'section@1/u-boot:size': len(U_BOOT_DATA), + 'section@1:pos': 16, + 'section@1:size': 16, + 'size': 40 + }, props) +

if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/60_fdt_update.dts b/tools/binman/test/60_fdt_update.dts new file mode 100644 index 00000000000..28e483fd7b5 --- /dev/null +++ b/tools/binman/test/60_fdt_update.dts @@ -0,0 +1,28 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + pad-byte = <0x26>; + size = <0x28>; + section@0 { + read-only; + name-prefix = "ro-"; + size = <0x10>; + pad-byte = <0x21>; + + u-boot { + }; + }; + section@1 { + name-prefix = "rw-"; + size = <0x10>; + pad-byte = <0x61>; + + u-boot { + }; + }; + }; +};