Merge tag 'dm-pull-9jul19-take2' of https://gitlab.denx.de/u-boot/custodians/u-boot-dm

[oweals/u-boot.git] / tools / binman / control.py

diff --git a/tools/binman/control.py b/tools/binman/control.py
index e9d48df03014cde346fd9175c5d32fb8b6d75e9a..20186ee1980282cfbd6b78d12d6ee1bbf7468fa3 100644 (file)
--- a/tools/binman/control.py
+++ b/tools/binman/control.py
@@ -1,20 +1,21 @@
+# SPDX-License-Identifier: GPL-2.0+
 # Copyright (c) 2016 Google, Inc
 # Written by Simon Glass <sjg@chromium.org>
 #
-# SPDX-License-Identifier:      GPL-2.0+
-#
 # Creates binary images from input files controlled by a description
 #
 
+from __future__ import print_function
+
 from collections import OrderedDict
 import os
 import sys
 import tools
 
 import command
-import fdt
-import fdt_util
+import elf
 from image import Image
+import state
 import tout
 
 # List of images we plan to create
@@ -53,6 +54,18 @@ def _FindBinmanNode(dtb):
             return node
     return None
 
+def WriteEntryDocs(modules, test_missing=None):
+    """Write out documentation for all entries
+
+    Args:
+        modules: List of Module objects to get docs for
+        test_missing: Used for testing only, to force an entry's documeentation
+            to show as missing even if it is present. Should be set to None in
+            normal use.
+    """
+    from entry import Entry
+    Entry.WriteDocs(modules, test_missing)
+
 def Binman(options, args):
     """The main control code for binman
 
@@ -88,28 +101,97 @@ def Binman(options, args):
         options.indir.append(board_pathname)
 
     try:
+        # Import these here in case libfdt.py is not available, in which case
+        # the above help option still works.
+        import fdt
+        import fdt_util
+
         tout.Init(options.verbosity)
+        elf.debug = options.debug
+        state.use_fake_dtb = options.fake_dtb
         try:
             tools.SetInputDirs(options.indir)
             tools.PrepareOutputDir(options.outdir, options.preserve)
-            dtb = fdt.FdtScan(dtb_fname)
+            state.SetEntryArgs(options.entry_arg)
+
+            # 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.dtb.out')
+            tools.WriteFile(fname, tools.ReadFile(dtb_fname))
+            dtb = fdt.FdtScan(fname)
+
             node = _FindBinmanNode(dtb)
             if not node:
                 raise ValueError("Device tree '%s' does not have a 'binman' "
                                  "node" % dtb_fname)
+
             images = _ReadImageDesc(node)
+
+            if options.image:
+                skip = []
+                new_images = OrderedDict()
+                for name, image in images.items():
+                    if name in options.image:
+                        new_images[name] = image
+                    else:
+                        skip.append(name)
+                images = new_images
+                if skip and options.verbosity >= 2:
+                    print('Skipping images: %s' % ', '.join(skip))
+
+            state.Prepare(images, dtb)
+
+            # 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 offsets remain the same.
+            for image in images.values():
+                image.ExpandEntries()
+                if options.update_fdt:
+                    image.AddMissingProperties()
+                image.ProcessFdt(dtb)
+
+            for dtb_item in state.GetFdts():
+                dtb_item.Sync(auto_resize=True)
+                dtb_item.Pack()
+                dtb_item.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
                 # image will be reported after earlier images are already
                 # completed and written, but that does not seem important.
                 image.GetEntryContents()
-                image.GetEntryPositions()
-                image.PackEntries()
-                image.CheckSize()
-                image.CheckEntries()
+                image.GetEntryOffsets()
+                try:
+                    image.PackEntries()
+                    image.CheckSize()
+                    image.CheckEntries()
+                except Exception as e:
+                    if options.map:
+                        fname = image.WriteMap()
+                        print("Wrote map file '%s' to show errors"  % fname)
+                    raise
+                image.SetImagePos()
+                if options.update_fdt:
+                    image.SetCalculatedProperties()
+                    for dtb_item in state.GetFdts():
+                        dtb_item.Sync()
                 image.ProcessEntryContents()
+                image.WriteSymbols()
                 image.BuildImage()
+                if options.map:
+                    image.WriteMap()
+
+            # Write the updated FDTs to our output files
+            for dtb_item in state.GetFdts():
+                tools.WriteFile(dtb_item._fname, dtb_item.GetContents())
+
         finally:
             tools.FinaliseOutputDir()
     finally: