binman: fit: Compress generated fdt images and use it on Rockchip

index 9b39c711889..5eef1d57be9 100644
@@ -1297,12 +1297,27 @@ features to produce new behaviours.
         """
         algo = self.compress
         if algo != 'none':
-            algos = ['bzip2', 'gzip', 'lz4', 'lzma', 'lzo', 'xz', 'zstd']
-            if algo not in algos:
-                raise ValueError("Unknown algorithm '%s'" % algo)
-            names = {'lzma': 'lzma_alone', 'lzo': 'lzop'}
-            name = names.get(self.compress, self.compress)
-            self.comp_bintool = self.AddBintool(btools, name)
+            self.comp_bintool = self.AddBintool(
+                btools, self.get_comp_bintool_name(algo))
+
+    @staticmethod
+    def get_comp_bintool_name(algo):
+        """Get the name of the bintool which handles a compression algorithm
+
+        Args:
+            algo (str): Compression algorithm, e.g. 'gzip'
+
+        Returns:
+            str: Name of bintool
+
+        Raises:
+            ValueError: if the algorithm is not supported
+        """
+        algos = ['bzip2', 'gzip', 'lz4', 'lzma', 'lzo', 'xz', 'zstd']
+        if algo not in algos:
+            raise ValueError("Unknown algorithm '%s'" % algo)
+        names = {'lzma': 'lzma_alone', 'lzo': 'lzop'}
+        return names.get(algo, algo)
 
     @classmethod
     def AddBintool(self, tools, name):

index 4657ed1fd76..a81e3a1de0e 100644
@@ -274,6 +274,29 @@ class Entry_fit(Entry_section):
     string from the root node of the devicetree, so that things work correctly
     with FIT's configuration-matching algortihm.
 
+    Compressing the FDT images
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    The 'compression' property of an image node is copied into the FIT as
+    metadata only. It tells the loader how the data is stored, but binman does
+    not touch the data.
+    For generated FDT nodes, the 'fit,compress' property can be used to ask
+    binman to compress the .dtb as well. The algorithm is written to
+    the 'compression' property of each generated node, so it should
+    not also be given there::
+
+        images {
+            @fdt-SEQ {
+                description = "fdt-NAME";
+                type = "flat_dt";
+                fit,compress = "lzma";
+            };
+        };
+
+    Any algorithm supported by binman can be used (see the 'compress' property
+    of entries) except "xz" which FIT does not define or "none". The matching
+    compression tool must be installed.
+
     Dealing with phases
     ~~~~~~~~~~~~~~~~~~~
 

@@ -746,6 +769,26 @@ class Entry_fit(Entry_section):
 
         return tools.read_file(output_fname)
 
+    def _compress_fdt(self, algo, data):
+        """Compress the data of a generated fdt node
+
+        Args:
+            algo (str): Compression algorithm
+            data (bytes): Data to compress
+
+        Returns:
+            bytes: Compressed data
+
+        Raises:
+            ValueError: if the compression tool is not available
+        """
+        btool = self.fdt_comp_bintools[algo]
+        if not btool.is_present():
+            raise ValueError(
+                f"Cannot compress fdt with '{algo}': tool '{btool.name}' is "
+                f"missing")
+        return btool.compress(data)
+
     def _raise_subnode(self, node, msg):
         """Raise an error with a paticular FIT subnode
 

@@ -883,6 +926,7 @@ class Entry_fit(Entry_section):
                     else:
                         fname = tools.get_input_filename(fdt_fname + '.dtb')
                     fdt_phase = None
+                    compress = 'none'
                     with fsw.add_node(node_name):
                         for pname, prop in node.props.items():
                             if pname == 'fit,firmware':

@@ -902,6 +946,9 @@ class Entry_fit(Entry_section):
                                 fsw.property('compatible', prop.bytes)
                             elif pname == 'fit,fdt-phase':
                                 fdt_phase = fdt_util.GetString(node, pname)
+                            elif pname == 'fit,compress':
+                                compress = fdt_util.GetString(node, pname)
+                                fsw.property_string('compression', compress)
                             elif pname.startswith('fit,'):
                                 self._raise_subnode(
                                     node, f"Unknown directive '{pname}'")

@@ -922,6 +969,8 @@ class Entry_fit(Entry_section):
                                 data = tools.read_file(phase_fname)
                             else:
                                 data = tools.read_file(fname)
+                            if compress != 'none':
+                                data = self._compress_fdt(compress, data)
                             fsw.property('data', data)
 
                         for subnode in node.subnodes:

@@ -1148,10 +1197,28 @@ class Entry_fit(Entry_section):
             entry.SetImagePos(image_pos + self.offset)
 
     def AddBintools(self, btools):
+        # Add the tool for each algorithm requested by a generator node
         super().AddBintools(btools)
         self.mkimage = self.AddBintool(btools, 'mkimage')
         self.fdtgrep = self.AddBintool(btools, 'fdtgrep')
 
+        self.fdt_comp_bintools = {}
+        def _add_comp_bintools(node):
+            for prop in node.props.values():
+                if prop.name == 'fit,compress' and prop.value != 'none':
+                    if prop.value == 'xz':
+                        self._raise_subnode(
+                            node, "fit,compress 'xz' is not a FIT compression")
+                    try:
+                        name = self.get_comp_bintool_name(prop.value)
+                    except ValueError as exc:
+                        self._raise_subnode(node, str(exc))
+                    self.fdt_comp_bintools[prop.value] = self.AddBintool(
+                        btools, name)
+            for subnode in node.subnodes:
+                _add_comp_bintools(subnode)
+        _add_comp_bintools(self._node)
+
     def CheckMissing(self, missing_list):
         # We must use our private entry list for this since generator nodes
         # which are removed from self._entries will otherwise not show up as

new file mode 100644
index 00000000000..77c38fe9e05
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/dts-v1/;
+
+/ {
+	#address-cells = <1>;
+	#size-cells = <1>;
+
+	binman {
+		fit {
+			description = "test-desc";
+			#address-cells = <1>;
+			fit,fdt-list = "of-list";
+
+			images {
+				@fdt-SEQ {
+					description = "fdt-NAME.dtb";
+					type = "flat_dt";
+					fit,compress = "lzma";
+				};
+			};
+		};
+	};
+};

new file mode 100644
index 00000000000..93ea20272a4
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/dts-v1/;
+
+/ {
+	#address-cells = <1>;
+	#size-cells = <1>;
+
+	binman {
+		fit {
+			description = "test-desc";
+			#address-cells = <1>;
+			fit,fdt-list = "of-list";
+
+			images {
+				@fdt-SEQ {
+					description = "fdt-NAME.dtb";
+					type = "flat_dt";
+					fit,compress = "bad";
+				};
+			};
+		};
+	};
+};

new file mode 100644
index 00000000000..6c2d1c89399
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/dts-v1/;
+
+/ {
+	#address-cells = <1>;
+	#size-cells = <1>;
+
+	binman {
+		fit {
+			description = "test-desc";
+			#address-cells = <1>;
+			fit,fdt-list = "of-list";
+
+			images {
+				@fdt-SEQ {
+					description = "fdt-NAME.dtb";
+					type = "flat_dt";
+					fit,compress = "xz";
+				};
+			};
+		};
+	};
+};

index 8caf275d466..fdb22b0965f 100644
@@ -4357,6 +4357,50 @@ class TestFunctional(unittest.TestCase):
         """Test an image with an FIT with multiple FDT images"""
         self.CheckFitFdt()
 
+    def _FitFdtCompress(self, fname):
+        entry_args = {'of-list': 'test-fdt1 test-fdt2'}
+        extra_indirs = [os.path.join(self._indir, TEST_FDT_SUBDIR)]
+        return self._DoReadFileDtb(fname, entry_args=entry_args,
+                                   extra_indirs=extra_indirs)[0]
+
+    def testFitFdtCompress(self):
+        """Test that fit,compress compresses generated fdt images"""
+        bintool = self.comp_bintools['lzma_alone']
+        self._CheckBintool(bintool)
+        data = self._FitFdtCompress('fit/fdt_compress.dts')
+        dtb = fdt.Fdt.FromData(data)
+        dtb.Scan()
+        for seq, expected in ((1, TEST_FDT1_DATA), (2, TEST_FDT2_DATA)):
+            fnode = dtb.GetNode('/images/fdt-%d' % seq)
+            self.assertEqual('lzma', fnode.props['compression'].value)
+            self.assertNotIn('fit,compress', fnode.props)
+            comp = fnode.props['data'].bytes
+            self.assertNotEqual(expected, comp)
+            self.assertEqual(expected, bintool.decompress(comp))
+
+    def testFitFdtCompressBad(self):
+        """Test an unsupported fdt compression algorithm"""
+        with self.assertRaises(ValueError) as e:
+            self._FitFdtCompress('fit/fdt_compress_bad.dts')
+        self.assertIn("Unknown algorithm 'bad'", str(e.exception))
+
+    def testFitFdtCompressXz(self):
+        """Test that xz is rejected as it is not a FIT compression"""
+        with self.assertRaises(ValueError) as e:
+            self._FitFdtCompress('fit/fdt_compress_xz.dts')
+        self.assertIn("fit,compress 'xz' is not a FIT compression",
+                      str(e.exception))
+
+    def testFitFdtCompressMissing(self):
+        """Test that a missing compression tool is an error"""
+        with self.assertRaises(ValueError) as e:
+            self._DoTestFile('fit/fdt_compress.dts', allow_missing=True,
+                             force_missing_bintools='lzma_alone',
+                             entry_args={'of-list': 'test-fdt1 test-fdt2'},
+                             extra_indirs=[os.path.join(self._indir,
+                                                        TEST_FDT_SUBDIR)])
+        self.assertIn("tool 'lzma_alone' is missing", str(e.exception))
+
     def testFitFdtMissingList(self):
         """Test handling of a missing 'of-list' entry arg"""
         with self.assertRaises(ValueError) as e:

index 8fcdc36c931..b84a75062b4 100644
@@ -236,6 +236,38 @@ config SPL_FIT_FULL_CHECK
 	  advantage of bugs or omissions in the code. This includes a bad
 	  structure, multiple root nodes and the like.
 
+choice
+	prompt "Compression of the FDT in the FIT"
+	depends on SPL_FIT
+	default SPL_FIT_FDT_COMP_NONE
+	help
+	  Select how binman compresses the devicetrees in the FIT. This is
+	  independent of the compression of U-Boot itself. SPL must be able to
+	  decompress the chosen algorithm. Only boards whose binman description
+	  uses the fit,compress property are affected.
+
+config SPL_FIT_FDT_COMP_NONE
+	bool "None"
+	help
+	  Do not compress the devicetrees. This needs no decompression support
+	  in SPL but makes the FIT larger.
+
+config SPL_FIT_FDT_COMP_LZMA
+	bool "LZMA"
+	depends on SPL_LZMA
+	help
+	  Compress the devicetrees with LZMA. This gives the smallest FIT but
+	  needs the most time and memory to decompress in SPL.
+
+config SPL_FIT_FDT_COMP_GZIP
+	bool "gzip"
+	depends on SPL_GZIP
+	help
+	  Compress the devicetrees with gzip. This decompresses faster than
+	  LZMA in SPL but the FIT is larger.
+
+endchoice
+
 config SPL_FIT_SIGNATURE
 	bool "Enable signature verification of FIT firmware within SPL"
 	depends on SPL_DM

index 4ba6a87e78a..3cb571ddddb 100644
@@ -19,6 +19,19 @@
 #define FIT_UBOOT_COMP		"none"
 #endif
 
+/*
+ * The compression of the FDT is chosen by the SPL_FIT_FDT_COMP choice. It
+ * is independent of FIT_UBOOT_COMP so U-Boot may be gzip-compressed while the
+ * FDT is LZMA-compressed.
+ */
+#if defined(CONFIG_SPL_FIT_FDT_COMP_LZMA)
+#define FIT_FDT_COMP		"lzma"
+#elif defined(CONFIG_SPL_FIT_FDT_COMP_GZIP)
+#define FIT_FDT_COMP		"gzip"
+#else
+#define FIT_FDT_COMP		"none"
+#endif
+
 /*
  * SHA256 should be enabled in SPL when signature validation is involved,
  * CRC32 should only be used for basic checksum validation of FIT images.

@@ -136,7 +149,7 @@
 
 			@fdt-SEQ {
 				description = "fdt-NAME";
-				compression = "none";
+				fit,compress = FIT_FDT_COMP;
 				type = "flat_dt";
 #ifdef FIT_HASH_ALGO
 				hash {