[PATCH 0/3] add PBL handoff-data support

[PATCH 0/3] add PBL handoff-data support

[Sascha Hauer]

We need to pass data from the PBL to barebox proper. Right now we do
this with passing the data in registers which is quite limited. As the
amount of information that has to be passed increases it's time to
overcome this limitation.

This series introduces handoff-data which is a linked list of memory
blobs that can be passed from PBL to barebox proper. Board and SoC
code can append this list with their own entries and pick them up later
in barebox proper. The ARM architecture is converted over to use handoff
data, other architectures could follow.

Sascha Hauer (3):
  ARM: move blob_is_arm_boarddata() to include
  add handoff-data support
  ARM: pass handoff data from PBL to proper

 arch/arm/cpu/start.c               |  60 +++------
 arch/arm/cpu/uncompress.c          |  33 ++++-
 arch/arm/include/asm/barebox-arm.h |   7 ++
 include/handoff-data.h             |  48 ++++++++
 pbl/Makefile                       |   1 +
 pbl/handoff-data.c                 | 192 +++++++++++++++++++++++++++++
 6 files changed, 293 insertions(+), 48 deletions(-)
 create mode 100644 include/handoff-data.h
 create mode 100644 pbl/handoff-data.c

-- 
2.39.2

[PATCH 1/3] ARM: move blob_is_arm_boarddata() to include

[Sascha Hauer]

Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
---
 arch/arm/cpu/start.c               | 7 -------
 arch/arm/include/asm/barebox-arm.h | 7 +++++++
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/arch/arm/cpu/start.c b/arch/arm/cpu/start.c
index 6d0a7cfc6b..c13e93c243 100644
--- a/arch/arm/cpu/start.c
+++ b/arch/arm/cpu/start.c
@@ -36,13 +36,6 @@ static unsigned long arm_membase;
 static void *barebox_boarddata;
 static unsigned long barebox_boarddata_size;
 
-static bool blob_is_arm_boarddata(const void *blob)
-{
-	const struct barebox_arm_boarddata *bd = blob;
-
-	return bd->magic == BAREBOX_ARM_BOARDDATA_MAGIC;
-}
-
 const struct barebox_boarddata *barebox_get_boarddata(void)
 {
 	if (!barebox_boarddata || !blob_is_arm_boarddata(barebox_boarddata))
diff --git a/arch/arm/include/asm/barebox-arm.h b/arch/arm/include/asm/barebox-arm.h
index 4d70360b91..67f2b6ac45 100644
--- a/arch/arm/include/asm/barebox-arm.h
+++ b/arch/arm/include/asm/barebox-arm.h
@@ -32,6 +32,13 @@ void __noreturn barebox_arm_entry(unsigned long membase, unsigned long memsize,
 #define barebox_arm_boarddata		barebox_boarddata
 #define BAREBOX_ARM_BOARDDATA_MAGIC	BAREBOX_BOARDDATA_MAGIC
 
+static inline bool blob_is_arm_boarddata(const void *blob)
+{
+	const struct barebox_arm_boarddata *bd = blob;
+
+	return bd->magic == BAREBOX_ARM_BOARDDATA_MAGIC;
+}
+
 u32 barebox_arm_machine(void);
 
 unsigned long arm_mem_ramoops_get(void);
-- 
2.39.2

[PATCH 2/3] add handoff-data support

[Sascha Hauer]

We need to pass data from the PBL to barebox proper. Right now we do
this with passing the data in registers which is quite limited. As the
amount of information that has to be passed increases it's time to
overcome this limitation.

With this patch we introduce handoff-data which is a linked list of
memory blobs that can be passed from PBL to barebox proper.

The data format is done in a way that enables us to compile the list
entries and the data into the binary, so that no memory allocations
are needed in PBL.

Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
---
 include/handoff-data.h |  48 +++++++++++
 pbl/Makefile           |   1 +
 pbl/handoff-data.c     | 192 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 241 insertions(+)
 create mode 100644 include/handoff-data.h
 create mode 100644 pbl/handoff-data.c

diff --git a/include/handoff-data.h b/include/handoff-data.h
new file mode 100644
index 0000000000..f5586e22fe
--- /dev/null
+++ b/include/handoff-data.h
@@ -0,0 +1,48 @@
+#ifndef __HANDOFF_DATA_H
+#define __HANDOFF_DATA_H
+
+#include <linux/list.h>
+
+struct handoff_data {
+	struct list_head entries;
+};
+
+#define HANDOFF_DATA_BAREBOX(n)		(0x28061971 + (n))
+#define HANDOFF_DATA_INTERNAL_DT	HANDOFF_DATA_BAREBOX(0)
+#define HANDOFF_DATA_INTERNAL_DT_Z	HANDOFF_DATA_BAREBOX(1)
+#define HANDOFF_DATA_EXTERNAL_DT	HANDOFF_DATA_BAREBOX(2)
+#define HANDOFF_DATA_BOARDDATA		HANDOFF_DATA_BAREBOX(3)
+
+#define HANDOFF_DATA_BOARD(n)		(0x951726fb + (n))
+
+struct handoff_data_entry {
+	struct list_head list;
+	void *data;
+	size_t size;
+	unsigned int cookie;
+#define HANDOFF_DATA_FLAG_NO_COPY	BIT(0)
+	unsigned int flags;
+};
+
+#define handoff_data_add_flags(_cookie, _data, _size, _flags)	\
+	do {							\
+		static struct handoff_data_entry hde;		\
+		hde.cookie = _cookie;				\
+		hde.data = _data;				\
+		hde.size = _size;				\
+		hde.flags = _flags;				\
+								\
+		handoff_data_add_entry(&hde);			\
+	} while (0);
+
+#define handoff_data_add(_cookie, _data, _size)			\
+	handoff_data_add_flags((_cookie), (_data), (_size), 0)
+
+void handoff_data_add_entry(struct handoff_data_entry *entry);
+size_t handoff_data_size(void);
+void handoff_data_move(void *dest);
+void handoff_data_set(struct handoff_data *handoff);
+void *handoff_data_get_entry(unsigned int cookie, size_t *size);
+int handoff_data_show(void);
+
+#endif /* __HANDOFF_DATA_H */
diff --git a/pbl/Makefile b/pbl/Makefile
index f6e98e78be..79837c5611 100644
--- a/pbl/Makefile
+++ b/pbl/Makefile
@@ -8,3 +8,4 @@ pbl-y += string.o
 pbl-y += decomp.o
 pbl-$(CONFIG_LIBFDT) += fdt.o
 pbl-$(CONFIG_PBL_CONSOLE) += console.o
+obj-pbl-y += handoff-data.o
diff --git a/pbl/handoff-data.c b/pbl/handoff-data.c
new file mode 100644
index 0000000000..fcb27234a6
--- /dev/null
+++ b/pbl/handoff-data.c
@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <common.h>
+#include <handoff-data.h>
+#include <init.h>
+#include <linux/list.h>
+#include <memory.h>
+
+static struct handoff_data *handoff_data = (void *)-1;
+
+static struct handoff_data *handoff_data_get(void)
+{
+	static struct handoff_data __handoff_data;
+
+	/*
+	 * Sometimes the PBL copies itself to some other location and is
+	 * re-entered at that location. For example on some i.MX SoCs we have
+	 * to move the PBL out of the SRAM (which will be occupied by the TF-A
+	 * later). We force the handoff_data variable into the data segment.
+	 * When moving the PBL somewhere else with handoff_data set we move the
+	 * content of the variable with it and thus find it to have the correct
+	 * value in the new PBL.
+	 */
+	if (handoff_data == (void *)-1) {
+		handoff_data = &__handoff_data;
+		INIT_LIST_HEAD(&handoff_data->entries);
+	}
+
+	return handoff_data;
+}
+
+/**
+ * handoff_data_set - set the handoff data to be at a specified pointer
+ * @handoff: the place where the handoff data is
+ *
+ * This sets the handoff data to @handoff. To be used by barebox proper
+ * to pass the place where the handoff data has been placed by the PBL.
+ */
+void handoff_data_set(struct handoff_data *handoff)
+{
+	handoff_data = handoff;
+}
+
+/**
+ * handoff_data_add_entry - add a new handoff data entry
+ * @hde: the new entry
+ *
+ * This adds a new handoff data entry.
+ */
+void handoff_data_add_entry(struct handoff_data_entry *hde)
+{
+	struct handoff_data *hd = handoff_data_get();
+
+	list_add_tail(&hde->list, &hd->entries);
+}
+
+/**
+ * handoff_data_size - calculate the handoff data size
+ *
+ * This calculates the size needed for the current handoff data
+ * when put to a contiguous memory regions. Can be used to get the
+ * size needed in preparation for a handoff_data_move()
+ */
+size_t handoff_data_size(void)
+{
+	struct handoff_data *hd = handoff_data_get();
+	struct handoff_data_entry *hde;
+	size_t size = 0;
+	size_t dsize = 0;
+
+	dsize += sizeof(*hd);
+
+	list_for_each_entry(hde, &hd->entries, list) {
+		dsize += sizeof(*hde);
+		size += ALIGN(hde->size, 8);
+	}
+
+	return dsize + size;
+}
+
+/**
+ * handoff_data_move - move handoff data to specified destination
+ * @dest: The place where to move the handoff data to
+ *
+ * This moves the handoff data to @dest and also sets the new location
+ * to @dest. This can be used to move the handoff data to a contiguous
+ * region outside the binary. Note once moved no data should be added,
+ * as that would make the handoff_data discontigoous again.
+ */
+void handoff_data_move(void *dest)
+{
+	struct handoff_data *hd = handoff_data_get();
+	struct handoff_data *hdnew = dest;
+	struct handoff_data_entry *hde;
+
+	INIT_LIST_HEAD(&hdnew->entries);
+
+	dest = hdnew + 1;
+
+	list_for_each_entry(hde, &hd->entries, list) {
+		struct handoff_data_entry *newde = dest;
+
+		dest = newde + 1;
+
+		if (hde->flags & HANDOFF_DATA_FLAG_NO_COPY) {
+			newde->data = hde->data;
+		} else {
+			memcpy(dest, hde->data, hde->size);
+			newde->data = dest;
+			dest += ALIGN(hde->size, 8);
+		}
+
+		newde->size = hde->size;
+		newde->cookie = hde->cookie;
+		list_add_tail(&newde->list, &hdnew->entries);
+	}
+
+	handoff_data_set(hdnew);
+}
+
+/**
+ * handoff_data_get_entry - get the memory associated to a cookie
+ * @cookie: the cookie the data is identified with
+ * @size: size of the memory returned
+ *
+ * This returns the memory associated with @cookie.
+ */
+void *handoff_data_get_entry(unsigned int cookie, size_t *size)
+{
+	struct handoff_data *hd = handoff_data_get();
+	struct handoff_data_entry *hde;
+
+	list_for_each_entry(hde, &hd->entries, list) {
+		if (hde->cookie == cookie) {
+			*size = hde->size;
+			return hde->data;
+		}
+	}
+
+	return NULL;
+}
+
+/**
+ * handoff_data_show - show current handoff data entries
+ *
+ * This prints the current handoff data entries to the console for debugging
+ * purposes.
+ */
+int handoff_data_show(void)
+{
+	struct handoff_data *hd = handoff_data_get();
+	struct handoff_data_entry *hde;
+
+	list_for_each_entry(hde, &hd->entries, list) {
+		printf("handoff 0x%08x at 0x%p (size %zu)\n",
+			hde->cookie, hde->data, hde->size);
+	}
+
+	return 0;
+}
+
+static const char *handoff_data_entry_name(struct handoff_data_entry *hde)
+{
+	static char name[sizeof("handoff 12345678")];
+
+	switch (hde->cookie) {
+	case HANDOFF_DATA_INTERNAL_DT:
+		return "handoff FDT (internal)";
+	case HANDOFF_DATA_INTERNAL_DT_Z:
+		return "handoff FDT (internal, compressed)";
+	case HANDOFF_DATA_EXTERNAL_DT:
+		return "handoff FDT (external)";
+	case HANDOFF_DATA_BOARDDATA:
+		return "handoff boarddata";
+	default:
+		sprintf(name, "handoff %08x", hde->cookie);
+		return name;
+	}
+}
+
+static int handoff_data_reserve(void)
+{
+	struct handoff_data *hd = handoff_data_get();
+	struct handoff_data_entry *hde;
+
+	list_for_each_entry(hde, &hd->entries, list) {
+		const char *name = handoff_data_entry_name(hde);
+		request_sdram_region(name, (resource_size_t)hde->data, hde->size);
+	}
+
+	return 0;
+}
+late_initcall(handoff_data_reserve);
-- 
2.39.2

[PATCH 3/3] ARM: pass handoff data from PBL to proper

[Sascha Hauer]

Use newly introduced handoff data to pass data from PBL to barebox
proper. This will allow us later to pass more SoC and/or board specific
data from PBL to barebox proper.

Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
---
 arch/arm/cpu/start.c      | 53 ++++++++++++---------------------------
 arch/arm/cpu/uncompress.c | 33 +++++++++++++++++++++---
 2 files changed, 45 insertions(+), 41 deletions(-)

diff --git a/arch/arm/cpu/start.c b/arch/arm/cpu/start.c
index c13e93c243..b9dbe1f2fb 100644
--- a/arch/arm/cpu/start.c
+++ b/arch/arm/cpu/start.c
@@ -21,6 +21,7 @@
 #include <asm/mmu.h>
 #include <linux/kasan.h>
 #include <memory.h>
+#include <handoff-data.h>
 #include <uncompress.h>
 #include <compressed-dtb.h>
 #include <malloc.h>
@@ -38,10 +39,9 @@ static unsigned long barebox_boarddata_size;
 
 const struct barebox_boarddata *barebox_get_boarddata(void)
 {
-	if (!barebox_boarddata || !blob_is_arm_boarddata(barebox_boarddata))
-		return NULL;
+	size_t size;
 
-	return barebox_boarddata;
+	return handoff_data_get_entry(HANDOFF_DATA_BOARDDATA, &size);
 }
 
 u32 barebox_arm_machine(void)
@@ -56,19 +56,24 @@ void *barebox_arm_boot_dtb(void)
 	int ret = 0;
 	struct barebox_boarddata_compressed_dtb *compressed_dtb;
 	static void *boot_dtb;
+	void *blob;
+	size_t size;
 
 	if (boot_dtb)
 		return boot_dtb;
 
-	if (barebox_boarddata && blob_is_fdt(barebox_boarddata)) {
-		pr_debug("%s: using barebox_boarddata\n", __func__);
-		return barebox_boarddata;
-	}
+	blob = handoff_data_get_entry(HANDOFF_DATA_INTERNAL_DT, &size);
+	if (blob)
+		return blob;
+
+	blob = handoff_data_get_entry(HANDOFF_DATA_INTERNAL_DT_Z, &size);
+	if (!blob)
+		return NULL;
 
-	if (!fdt_blob_can_be_decompressed(barebox_boarddata))
+	if (!fdt_blob_can_be_decompressed(blob))
 		return NULL;
 
-	compressed_dtb = barebox_boarddata;
+	compressed_dtb = blob;
 
 	pr_debug("%s: using compressed_dtb\n", __func__);
 
@@ -167,34 +172,6 @@ __noreturn __prereloc void barebox_non_pbl_start(unsigned long membase,
 	arm_barebox_size = barebox_size;
 	malloc_end = barebox_base;
 
-	if (boarddata) {
-		uint32_t totalsize = 0;
-		const char *name;
-
-		if (blob_is_fdt(boarddata)) {
-			totalsize = get_unaligned_be32(boarddata + 4);
-			name = "DTB";
-		} else if (blob_is_compressed_fdt(boarddata)) {
-			struct barebox_boarddata_compressed_dtb *bd = boarddata;
-			totalsize = bd->datalen + sizeof(*bd);
-			name = "Compressed DTB";
-		} else if (blob_is_arm_boarddata(boarddata)) {
-			totalsize = sizeof(struct barebox_arm_boarddata);
-			name = "machine type";
-		}
-
-		if (totalsize) {
-			unsigned long mem = arm_mem_boarddata(membase, endmem,
-							      totalsize);
-			pr_debug("found %s in boarddata, copying to 0x%08lx\n",
-				 name, mem);
-			barebox_boarddata = memcpy((void *)mem, boarddata,
-						   totalsize);
-			barebox_boarddata_size = totalsize;
-			malloc_end = mem;
-		}
-	}
-
 	/*
 	 * Maximum malloc space is the Kconfig value if given
 	 * or 1GB.
@@ -216,6 +193,8 @@ __noreturn __prereloc void barebox_non_pbl_start(unsigned long membase,
 
 	mem_malloc_init((void *)malloc_start, (void *)malloc_end - 1);
 
+	handoff_data_set(boarddata);
+
 	if (IS_ENABLED(CONFIG_BOOTM_OPTEE))
 		of_add_reserve_entry(endmem - OPTEE_SIZE, endmem - 1);
 
diff --git a/arch/arm/cpu/uncompress.c b/arch/arm/cpu/uncompress.c
index aa1a49bfc9..a29703e760 100644
--- a/arch/arm/cpu/uncompress.c
+++ b/arch/arm/cpu/uncompress.c
@@ -10,6 +10,7 @@
 #include <init.h>
 #include <linux/sizes.h>
 #include <pbl.h>
+#include <handoff-data.h>
 #include <asm/barebox-arm.h>
 #include <asm/barebox-arm-head.h>
 #include <asm-generic/memory_layout.h>
@@ -18,6 +19,7 @@
 #include <asm/cache.h>
 #include <asm/mmu.h>
 #include <asm/unaligned.h>
+#include <compressed-dtb.h>
 
 #include <debug_ll.h>
 
@@ -29,6 +31,22 @@ unsigned long free_mem_end_ptr;
 extern unsigned char input_data[];
 extern unsigned char input_data_end[];
 
+static void add_handoff_data(void *boarddata)
+{
+	if (blob_is_fdt(boarddata)) {
+		handoff_data_add(HANDOFF_DATA_INTERNAL_DT, boarddata,
+				 get_unaligned_be32(boarddata + 4));
+	} else if (blob_is_compressed_fdt(boarddata)) {
+		struct barebox_boarddata_compressed_dtb *bd = boarddata;
+
+		handoff_data_add(HANDOFF_DATA_INTERNAL_DT_Z, boarddata,
+				 bd->datalen + sizeof(*bd));
+	} else if (blob_is_arm_boarddata(boarddata)) {
+		handoff_data_add(HANDOFF_DATA_BOARDDATA, boarddata,
+				 sizeof(struct barebox_arm_boarddata));
+	}
+}
+
 void __noreturn barebox_pbl_start(unsigned long membase, unsigned long memsize,
 				  void *boarddata)
 {
@@ -38,6 +56,7 @@ void __noreturn barebox_pbl_start(unsigned long membase, unsigned long memsize,
 	unsigned long barebox_base;
 	void *pg_start, *pg_end;
 	unsigned long pc = get_pc();
+	void *handoff_data;
 
 	/* piggy data is not relocated, so determine the bounds now */
 	pg_start = runtime_address(input_data);
@@ -56,9 +75,6 @@ void __noreturn barebox_pbl_start(unsigned long membase, unsigned long memsize,
 	pg_len = pg_end - pg_start;
 	uncompressed_len = get_unaligned((const u32 *)(pg_start + pg_len - 4));
 
-	barebox_base = arm_mem_barebox_image(membase, endmem,
-					     uncompressed_len + MAX_BSS_SIZE);
-
 	setup_c();
 
 	pr_debug("memory at 0x%08lx, size 0x%08lx\n", membase, memsize);
@@ -69,11 +85,20 @@ void __noreturn barebox_pbl_start(unsigned long membase, unsigned long memsize,
 	free_mem_ptr = arm_mem_early_malloc(endmem);
 	free_mem_end_ptr = arm_mem_early_malloc_end(endmem);
 
+	barebox_base = arm_mem_barebox_image(membase, endmem,
+					     uncompressed_len + MAX_BSS_SIZE + handoff_data_size());
+
+	handoff_data = (void *)barebox_base + uncompressed_len + MAX_BSS_SIZE;
+
 	pr_debug("uncompressing barebox binary at 0x%p (size 0x%08x) to 0x%08lx (uncompressed size: 0x%08x)\n",
 			pg_start, pg_len, barebox_base, uncompressed_len);
 
 	pbl_barebox_uncompress((void*)barebox_base, pg_start, pg_len);
 
+	add_handoff_data(boarddata);
+
+	handoff_data_move(handoff_data);
+
 	sync_caches_for_execution();
 
 	if (IS_ENABLED(CONFIG_THUMB2_BAREBOX))
@@ -86,5 +111,5 @@ void __noreturn barebox_pbl_start(unsigned long membase, unsigned long memsize,
 	if (IS_ENABLED(CONFIG_CPU_V7) && boot_cpu_mode() == HYP_MODE)
 		armv7_switch_to_hyp();
 
-	barebox(membase, memsize, boarddata);
+	barebox(membase, memsize, handoff_data);
 }
-- 
2.39.2

Re: [PATCH 1/3] ARM: move blob_is_arm_boarddata() to include

[Ahmad Fatoum]

On 30.04.24 12:53, Sascha Hauer wrote:
> Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>

Reviewed-by: Ahmad Fatoum <a.fatoum@pengutronix.de>

> ---
>  arch/arm/cpu/start.c               | 7 -------
>  arch/arm/include/asm/barebox-arm.h | 7 +++++++
>  2 files changed, 7 insertions(+), 7 deletions(-)
> 
> diff --git a/arch/arm/cpu/start.c b/arch/arm/cpu/start.c
> index 6d0a7cfc6b..c13e93c243 100644
> --- a/arch/arm/cpu/start.c
> +++ b/arch/arm/cpu/start.c
> @@ -36,13 +36,6 @@ static unsigned long arm_membase;
>  static void *barebox_boarddata;
>  static unsigned long barebox_boarddata_size;
>  
> -static bool blob_is_arm_boarddata(const void *blob)
> -{
> -	const struct barebox_arm_boarddata *bd = blob;
> -
> -	return bd->magic == BAREBOX_ARM_BOARDDATA_MAGIC;
> -}
> -
>  const struct barebox_boarddata *barebox_get_boarddata(void)
>  {
>  	if (!barebox_boarddata || !blob_is_arm_boarddata(barebox_boarddata))
> diff --git a/arch/arm/include/asm/barebox-arm.h b/arch/arm/include/asm/barebox-arm.h
> index 4d70360b91..67f2b6ac45 100644
> --- a/arch/arm/include/asm/barebox-arm.h
> +++ b/arch/arm/include/asm/barebox-arm.h
> @@ -32,6 +32,13 @@ void __noreturn barebox_arm_entry(unsigned long membase, unsigned long memsize,
>  #define barebox_arm_boarddata		barebox_boarddata
>  #define BAREBOX_ARM_BOARDDATA_MAGIC	BAREBOX_BOARDDATA_MAGIC
>  
> +static inline bool blob_is_arm_boarddata(const void *blob)
> +{
> +	const struct barebox_arm_boarddata *bd = blob;
> +
> +	return bd->magic == BAREBOX_ARM_BOARDDATA_MAGIC;
> +}
> +
>  u32 barebox_arm_machine(void);
>  
>  unsigned long arm_mem_ramoops_get(void);

-- 
Pengutronix e.K.                           |                             |
Steuerwalder Str. 21                       | http://www.pengutronix.de/  |
31137 Hildesheim, Germany                  | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |

Re: [PATCH 0/3] add PBL handoff-data support

[Sascha Hauer]

On Tue, 30 Apr 2024 12:53:07 +0200, Sascha Hauer wrote:
> We need to pass data from the PBL to barebox proper. Right now we do
> this with passing the data in registers which is quite limited. As the
> amount of information that has to be passed increases it's time to
> overcome this limitation.
> 
> This series introduces handoff-data which is a linked list of memory
> blobs that can be passed from PBL to barebox proper. Board and SoC
> code can append this list with their own entries and pick them up later
> in barebox proper. The ARM architecture is converted over to use handoff
> data, other architectures could follow.
> 
> [...]

Applied, thanks!

[1/3] ARM: move blob_is_arm_boarddata() to include
      https://git.pengutronix.de/cgit/barebox/commit/?id=c78e0862d540 (link may not be stable)
[2/3] add handoff-data support
      https://git.pengutronix.de/cgit/barebox/commit/?id=6b17d1443632 (link may not be stable)
[3/3] ARM: pass handoff data from PBL to proper
      https://git.pengutronix.de/cgit/barebox/commit/?id=637231379c32 (link may not be stable)

Best regards,
-- 
Sascha Hauer <s.hauer@pengutronix.de>