Skip to contentSkip to conversation

Add support for loading images above 4GB

PATCH New Michal Simek 3 participants 17 messages Sep 3, 2020 – Oct 5, 2020

lore
Share & tools
lore
#0 lore raw

cover Add support for loading images above 4GB

Hi,

We have several use cases where customers want to partition memory by putting NS images above 4GB. On Xilinx arm 64bit SOC 0-2GB can be used for others CPU in the systems (like R5) or for secure sw. Currently there is limitation in SPL to record load/entry addresses in 64bit format because they are recorded in 32bit only.
This series add support for it.
Patches have been tested on Xilinx ZynqMP zcu102 board in SD bootmode with images generated by binman. Because u-boot is using CONFIG_POSITION_INDEPENDENT it can be put to others 4k aligned addresses and there is no real need to build it to certain offset.

Thanks,
Michal

Michal Simek (2):
spl: Use standard FIT entries
spl: fdt: Record load/entry fit-images entries in 64bit format

 common/fdt_support.c | 9 ++-------
 common/spl/spl_atf.c | 7 ++++---
 common/spl/spl_fit.c | 6 +++++-
 3 files changed, 11 insertions(+), 11 deletions(-)
Signature · 1 line
2.28.0
#1 lore raw

PATCH 1/2 spl: Use standard FIT entries

SPL is creating fit-images DT node when loadables are recorded in selected configuration. Entries which are created are using entry-point and
load-addr property names. But there shouldn't be a need to use non standard properties because entry/load are standard FIT properties. But using
standard FIT properties enables option to use generic FIT functions to descrease SPL size. Here is result for ZynqMP virt configuration:
xilinx_zynqmp_virt: spl/u-boot-spl:all -82 spl/u-boot-spl:rodata -22 spl/u-boot-spl:text -60

The patch causes change in run time fit image record. Before:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry-point = <0x8000000>;
                load-addr = <0x8000000>;
        };
};

After:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry = <0x8000000>;
                load = <0x8000000>;
        };
};

Replacing calling fdt_getprop_u32() by fit_image_get_entry/load() also enables support for reading entry/load properties recorded in 64bit format.

---

Would be good to know history of fit-images and it's property names but there shouldn't be a need to use non standard names where we have FIT_*_PROP recorded as macros in include/image.h.

Concern regarding backward compatibility is definitely valid but not sure how many systems can be affected by this change.

Adding temporary support for entry-point/load-addr is also possible. Or second way around is to create new wrappers as fit_image_get_entry_point()/fit_image_get_load_addr() or call fit_image_get_address() directly.

---
 common/fdt_support.c | 4 ++--
 common/spl/spl_atf.c | 7 ++++---
 common/spl/spl_fit.c | 6 +++++-
 3 files changed, 11 insertions(+), 6 deletions(-)
common/fdt_support.c +2 -2
index a565b470f81e..b8a8768a2147 100644
@@ -616,9 +616,9 @@ int fdt_record_loadable(void *blob, u32 index, const char *name,
 	 * However, spl_fit.c is not 64bit safe either: i.e. we should not
 	 * have an issue here.
 	 */
-	fdt_setprop_u32(blob, node, "load-addr", load_addr);
+	fdt_setprop_u32(blob, node, "load", load_addr);
 	if (entry_point != -1)
-		fdt_setprop_u32(blob, node, "entry-point", entry_point);
+		fdt_setprop_u32(blob, node, "entry", entry_point);
 	fdt_setprop_u32(blob, node, "size", size);
 	if (type)
 		fdt_setprop_string(blob, node, "type", type);
common/spl/spl_atf.c +4 -3
index b54b4f0d22e2..9bd25f6b32c1 100644
@@ -132,10 +132,11 @@ static int spl_fit_images_find(void *blob, int os)
 uintptr_t spl_fit_images_get_entry(void *blob, int node)
 {
 	ulong  val;
+	int ret;
 
-	val = fdt_getprop_u32(blob, node, "entry-point");
-	if (val == FDT_ERROR)
-		val = fdt_getprop_u32(blob, node, "load-addr");
+	ret = fit_image_get_entry(blob, node, &val);
+	if (ret)
+		ret = fit_image_get_load(blob, node, &val);
 
 	debug("%s: entry point 0x%lx\n", __func__, val);
 	return val;
common/spl/spl_fit.c +5 -1
index 365104fe0288..b69b3948841f 100644
@@ -332,9 +332,13 @@ static int spl_load_fit_image(struct spl_load_info *info, ulong sector,
 	}
 
 	if (image_info) {
+		ulong entry_point;
+
 		image_info->load_addr = load_addr;
 		image_info->size = length;
-		image_info->entry_point = fdt_getprop_u32(fit, node, "entry");
+
+		if (!fit_image_get_entry(fit, node, &entry_point))
+			image_info->entry_point = entry_point;
 	}
 
 	return 0;
Signature · 1 line
2.28.0
#2 lore raw

PATCH 1/2 spl: Use standard FIT entries

Hi Michal,

Quoted 32 lines · Michal Simek

SPL is creating fit-images DT node when loadables are recorded in selected configuration. Entries which are created are using entry-point and
load-addr property names. But there shouldn't be a need to use non standard properties because entry/load are standard FIT properties. But using
standard FIT properties enables option to use generic FIT functions to descrease SPL size. Here is result for ZynqMP virt configuration:
xilinx_zynqmp_virt: spl/u-boot-spl:all -82 spl/u-boot-spl:rodata -22 spl/u-boot-spl:text -60

The patch causes change in run time fit image record. Before:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry-point = <0x8000000>;
                load-addr = <0x8000000>;
        };
};

After:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry = <0x8000000>;
                load = <0x8000000>;
        };
};
Quoted 5 lines

Replacing calling fdt_getprop_u32() by fit_image_get_entry/load() also enables support for reading entry/load properties recorded in 64bit format.

---

Isn't there a test that could be updated here?

Quoted 4 lines

Would be good to know history of fit-images and it's property names but there shouldn't be a need to use non standard names where we have FIT_*_PROP recorded as macros in include/image.h.

I agree.

Quoted 2 lines

Concern regarding backward compatibility is definitely valid but not sure how many systems can be affected by this change.

Me neither. Probably a good idea to fix it.

Quoted 6 lines

Adding temporary support for entry-point/load-addr is also possible. Or second way around is to create new wrappers as fit_image_get_entry_point()/fit_image_get_load_addr() or call fit_image_get_address() directly.

Quoted 6 lines
---
 common/fdt_support.c | 4 ++--
 common/spl/spl_atf.c | 7 ++++---
 common/spl/spl_fit.c | 6 +++++-
 3 files changed, 11 insertions(+), 6 deletions(-)

Regards,
SImon

#3 lore raw

PATCH 1/2 spl: Use standard FIT entries

Hi Simon,

Quoted 38 lines · Simon Glass

Hi Michal,

Quoted 35 lines · Michal Simek

SPL is creating fit-images DT node when loadables are recorded in selected configuration. Entries which are created are using entry-point and
load-addr property names. But there shouldn't be a need to use non standard properties because entry/load are standard FIT properties. But using
standard FIT properties enables option to use generic FIT functions to descrease SPL size. Here is result for ZynqMP virt configuration:
xilinx_zynqmp_virt: spl/u-boot-spl:all -82 spl/u-boot-spl:rodata -22 spl/u-boot-spl:text -60

The patch causes change in run time fit image record. Before:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry-point = <0x8000000>;
                load-addr = <0x8000000>;
        };
};

After:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry = <0x8000000>;
                load = <0x8000000>;
        };
};

Replacing calling fdt_getprop_u32() by fit_image_get_entry/load() also enables support for reading entry/load properties recorded in 64bit format.

Quoted 6 lines
Quoted 2 lines

---

Isn't there a test that could be updated here?

Are we testing SPL flow?

Quoted 6 lines
Quoted 5 lines

Would be good to know history of fit-images and it's property names but there shouldn't be a need to use non standard names where we have FIT_*_PROP recorded as macros in include/image.h.

Quoted 6 lines

I agree.

Quoted 2 lines

Concern regarding backward compatibility is definitely valid but not sure how many systems can be affected by this change.

Me neither. Probably a good idea to fix it.

Fix means keep existing code with warning and add new one next to it.

M

#4 lore raw

PATCH 1/2 spl: Use standard FIT entries

Hi Michal,

Quoted 57 lines · Michal Simek

Hi Simon,

Quoted 38 lines · Simon Glass

Hi Michal,

Quoted 35 lines · Michal Simek

SPL is creating fit-images DT node when loadables are recorded in selected configuration. Entries which are created are using entry-point and
load-addr property names. But there shouldn't be a need to use non standard properties because entry/load are standard FIT properties. But using
standard FIT properties enables option to use generic FIT functions to descrease SPL size. Here is result for ZynqMP virt configuration:
xilinx_zynqmp_virt: spl/u-boot-spl:all -82 spl/u-boot-spl:rodata -22 spl/u-boot-spl:text -60

The patch causes change in run time fit image record. Before:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry-point = <0x8000000>;
                load-addr = <0x8000000>;
        };
};

After:

fit-images {
        uboot {
                os = "u-boot";
                type = "firmware";
                size = <0xfd520>;
                entry = <0x8000000>;
                load = <0x8000000>;
        };
};

Replacing calling fdt_getprop_u32() by fit_image_get_entry/load() also enables support for reading entry/load properties recorded in 64bit format.

Quoted 6 lines
Quoted 2 lines

---

Isn't there a test that could be updated here?

Are we testing SPL flow?

Quoted 6 lines
Quoted 5 lines

Would be good to know history of fit-images and it's property names but there shouldn't be a need to use non standard names where we have FIT_*_PROP recorded as macros in include/image.h.

Quoted 8 lines
Quoted 6 lines

I agree.

Quoted 2 lines

Concern regarding backward compatibility is definitely valid but not sure how many systems can be affected by this change.

Me neither. Probably a good idea to fix it.

Fix means keep existing code with warning and add new one next to it.

No, I mean use your code as here and document with a test, etc. If it breaks anything, it can be fixed.

Regards,
SImon

#5 lore raw

PATCH 2/2 spl: fdt: Record load/entry fit-images entries in 64bit format

In reply to Michal Simek

The commit 9f45aeb93727 ("spl: fit: implement fdt_record_loadable") which introduced fdt_record_loadable() state there spl_fit.c is not 64bit safe. Based on my tests on Xilinx ZynqMP zcu102 platform there shouldn't be a problem to record these addresses in 64bit format.
The patch adds support for systems which need to load images above 4GB.

---

 common/fdt_support.c | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)
common/fdt_support.c +2 -7
index b8a8768a2147..5ae75df3c658 100644
@@ -611,14 +611,9 @@ int fdt_record_loadable(void *blob, u32 index, const char *name,
 	if (node < 0)
 		return node;
 
-	/*
-	 * We record these as 32bit entities, possibly truncating addresses.
-	 * However, spl_fit.c is not 64bit safe either: i.e. we should not
-	 * have an issue here.
-	 */
-	fdt_setprop_u32(blob, node, "load", load_addr);
+	fdt_setprop_u64(blob, node, "load", load_addr);
 	if (entry_point != -1)
-		fdt_setprop_u32(blob, node, "entry", entry_point);
+		fdt_setprop_u64(blob, node, "entry", entry_point);
 	fdt_setprop_u32(blob, node, "size", size);
 	if (type)
 		fdt_setprop_string(blob, node, "type", type);
Signature · 1 line
2.28.0
#6 lore raw

PATCH 2/2 spl: fdt: Record load/entry fit-images entries in 64bit format

Hi Michal,

Quoted 6 lines · Michal Simek

The commit 9f45aeb93727 ("spl: fit: implement fdt_record_loadable") which introduced fdt_record_loadable() state there spl_fit.c is not 64bit safe. Based on my tests on Xilinx ZynqMP zcu102 platform there shouldn't be a problem to record these addresses in 64bit format.
The patch adds support for systems which need to load images above 4GB.

But what about 32-bit systems who read this as a 32-bit number? Perhaps we should write 32-bit if !CONFIG_PHYS_64BIT?

Quoted 29 lines

---

 common/fdt_support.c | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)
common/fdt_support.c +2 -8
index b8a8768a2147..5ae75df3c658 100644
@@ -611,14 +611,9 @@ int fdt_record_loadable(void *blob, u32 index, const char *name,
        if (node < 0)
                return node;
 
-       /*
-        * We record these as 32bit entities, possibly truncating addresses.
-        * However, spl_fit.c is not 64bit safe either: i.e. we should not
-        * have an issue here.
-        */
-       fdt_setprop_u32(blob, node, "load", load_addr);
+       fdt_setprop_u64(blob, node, "load", load_addr);
        if (entry_point != -1)
-               fdt_setprop_u32(blob, node, "entry", entry_point);
+               fdt_setprop_u64(blob, node, "entry", entry_point);
        fdt_setprop_u32(blob, node, "size", size);
        if (type)
                fdt_setprop_string(blob, node, "type", type);
--
Quoted 2 lines

2.28.0

Regards,
SImon

#7 lore raw

PATCH 2/2 spl: fdt: Record load/entry fit-images entries in 64bit format

Quoted 4 lines · Simon Glass

Hi Michal,

Quoted 1 line · Michal Simek
Quoted 8 lines
Quoted 5 lines

The commit 9f45aeb93727 ("spl: fit: implement fdt_record_loadable") which introduced fdt_record_loadable() state there spl_fit.c is not 64bit safe. Based on my tests on Xilinx ZynqMP zcu102 platform there shouldn't be a problem to record these addresses in 64bit format.
The patch adds support for systems which need to load images above 4GB.

But what about 32-bit systems who read this as a 32-bit number? Perhaps we should write 32-bit if !CONFIG_PHYS_64BIT?

The code for reading doesn't really care if value is 32bit or 64bit. The fit_image_get_entry() and fit_image_get_load() read number of cells used and based on that read 32 or 64 bit values.

Thanks,
Michal

#8 lore raw

PATCH 2/2 spl: fdt: Record load/entry fit-images entries in 64bit format

Hi Michal,

Quoted 14 lines · Michal Simek
Quoted 10 lines · Simon Glass

Hi Michal,

Quoted 6 lines · Michal Simek

The commit 9f45aeb93727 ("spl: fit: implement fdt_record_loadable") which introduced fdt_record_loadable() state there spl_fit.c is not 64bit safe. Based on my tests on Xilinx ZynqMP zcu102 platform there shouldn't be a problem to record these addresses in 64bit format.
The patch adds support for systems which need to load images above 4GB.

Quoted 6 lines
Quoted 2 lines

But what about 32-bit systems who read this as a 32-bit number? Perhaps we should write 32-bit if !CONFIG_PHYS_64BIT?

The code for reading doesn't really care if value is 32bit or 64bit. The fit_image_get_entry() and fit_image_get_load() read number of cells used and based on that read 32 or 64 bit values.

Sorry I wrote that before looking at the function. The functions should have header-file comments that indicate what they do.

Regards,
Simon

#9 lore raw

PATCH 2/2 spl: fdt: Record load/entry fit-images entries in 64bit format

Quoted 20 lines · Simon Glass

Hi Michal,

Quoted 17 lines · Michal Simek
Quoted 12 lines · Simon Glass

Hi Michal,

Quoted 6 lines · Michal Simek

The commit 9f45aeb93727 ("spl: fit: implement fdt_record_loadable") which introduced fdt_record_loadable() state there spl_fit.c is not 64bit safe. Based on my tests on Xilinx ZynqMP zcu102 platform there shouldn't be a problem to record these addresses in 64bit format.
The patch adds support for systems which need to load images above 4GB.

But what about 32-bit systems who read this as a 32-bit number? Perhaps we should write 32-bit if !CONFIG_PHYS_64BIT?

Quoted 6 lines
Quoted 3 lines

The code for reading doesn't really care if value is 32bit or 64bit. The fit_image_get_entry() and fit_image_get_load() read number of cells used and based on that read 32 or 64 bit values.

Sorry I wrote that before looking at the function. The functions should have header-file comments that indicate what they do.

kernel-doc format is in common/image-fit.c already.

M

#10 lore raw

PATCH 2/2 spl: fdt: Record load/entry fit-images entries in 64bit format

In reply to Simon Glass

+andestech.com

Quoted 28 lines · Simon Glass

Hi Michal,

Quoted 6 lines · Michal Simek

The commit 9f45aeb93727 ("spl: fit: implement fdt_record_loadable") which introduced fdt_record_loadable() state there spl_fit.c is not 64bit safe. Based on my tests on Xilinx ZynqMP zcu102 platform there shouldn't be a problem to record these addresses in 64bit format.
The patch adds support for systems which need to load images above 4GB.

But what about 32-bit systems who read this as a 32-bit number? Perhaps we should write 32-bit if !CONFIG_PHYS_64BIT?

Quoted 15 lines

---

 common/fdt_support.c | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)
common/fdt_support.c +0 -0
index b8a8768a2147..5ae75df3c658 100644
@@ -611,14 +611,9 @@ int fdt_record_loadable(void *blob, u32 index, const char *name,
        if (node < 0)
                return node;
 
Quoted 16 lines
Quoted 14 lines
common/fdt_support.c +2 -8
-       /*
-        * We record these as 32bit entities, possibly truncating addresses.
-        * However, spl_fit.c is not 64bit safe either: i.e. we should not
-        * have an issue here.
-        */
-       fdt_setprop_u32(blob, node, "load", load_addr);
+       fdt_setprop_u64(blob, node, "load", load_addr);
        if (entry_point != -1)
-               fdt_setprop_u32(blob, node, "entry", entry_point);
+               fdt_setprop_u64(blob, node, "entry", entry_point);
        fdt_setprop_u32(blob, node, "size", size);
        if (type)
                fdt_setprop_string(blob, node, "type", type);
--
Quoted 2 lines

2.28.0

riscv: Your code is also using entry-point/load-addr and should be also fixed based on this series. Can you please take a look at this series? I am interested how riscv users are keeping in sync SPL and full U-Boot.

Thanks,
Michal

#11 lore raw

cover Add support for loading images above 4GB

In reply to Michal Simek
Quoted 13 lines · Michal Simek

Hi,

We have several use cases where customers want to partition memory by putting NS images above 4GB. On Xilinx arm 64bit SOC 0-2GB can be used for others CPU in the systems (like R5) or for secure sw. Currently there is limitation in SPL to record load/entry addresses in 64bit format because they are recorded in 32bit only.
This series add support for it.
Patches have been tested on Xilinx ZynqMP zcu102 board in SD bootmode with images generated by binman. Because u-boot is using CONFIG_POSITION_INDEPENDENT it can be put to others 4k aligned addresses and there is no real need to build it to certain offset.

Quoted 2 lines

Thanks,
Michal

Hello Michal,

does this series require changes to doc/uImage.FIT/source_file_format.txt?

Best regards

Heinrich

Quoted 11 lines

Michal Simek (2):
spl: Use standard FIT entries
spl: fdt: Record load/entry fit-images entries in 64bit format

 common/fdt_support.c | 9 ++-------
 common/spl/spl_atf.c | 7 ++++---
 common/spl/spl_fit.c | 6 +++++-
 3 files changed, 11 insertions(+), 11 deletions(-)
#12 lore raw

cover Add support for loading images above 4GB

Hi,

Quoted 14 lines · Heinrich Schuchardt
Quoted 13 lines · Michal Simek

Hi,

We have several use cases where customers want to partition memory by putting NS images above 4GB. On Xilinx arm 64bit SOC 0-2GB can be used for others CPU in the systems (like R5) or for secure sw. Currently there is limitation in SPL to record load/entry addresses in 64bit format because they are recorded in 32bit only.
This series add support for it.
Patches have been tested on Xilinx ZynqMP zcu102 board in SD bootmode with images generated by binman. Because u-boot is using CONFIG_POSITION_INDEPENDENT it can be put to others 4k aligned addresses and there is no real need to build it to certain offset.

Quoted 6 lines
Quoted 2 lines

Thanks,
Michal

Hello Michal,

does this series require changes to doc/uImage.FIT/source_file_format.txt?

I am not changing fit format. I am just changing how SPL records loadables in DT fit-images node. And also series is using FIT functions for reading these properties (at least in this version).

Thanks,
Michal

#13 lore raw

cover Add support for loading images above 4GB

Hi Michal,

Quoted 21 lines · Michal Simek

Hi,

Quoted 17 lines · Heinrich Schuchardt
Quoted 15 lines · Michal Simek

Hi,

We have several use cases where customers want to partition memory by putting NS images above 4GB. On Xilinx arm 64bit SOC 0-2GB can be used for others CPU in the systems (like R5) or for secure sw. Currently there is limitation in SPL to record load/entry addresses in 64bit format because they are recorded in 32bit only.
This series add support for it.
Patches have been tested on Xilinx ZynqMP zcu102 board in SD bootmode with images generated by binman. Because u-boot is using CONFIG_POSITION_INDEPENDENT it can be put to others 4k aligned addresses and there is no real need to build it to certain offset.

Thanks,
Michal

Quoted 7 lines
Quoted 3 lines

Hello Michal,

does this series require changes to doc/uImage.FIT/source_file_format.txt?

I am not changing fit format. I am just changing how SPL records loadables in DT fit-images node. And also series is using FIT functions for reading these properties (at least in this version).

Well I think there should be some mention of the 32/64 bit issue added to the FIT docs. How about adding an example with 64-bit addresses?

Regards,
Simon
'

#14 lore raw

cover Add support for loading images above 4GB

Hi Simon,

Quoted 26 lines · Simon Glass

Hi Michal,

Quoted 23 lines · Michal Simek

Hi,

Quoted 19 lines · Heinrich Schuchardt
Quoted 13 lines · Michal Simek

Hi,

We have several use cases where customers want to partition memory by putting NS images above 4GB. On Xilinx arm 64bit SOC 0-2GB can be used for others CPU in the systems (like R5) or for secure sw. Currently there is limitation in SPL to record load/entry addresses in 64bit format because they are recorded in 32bit only.
This series add support for it.
Patches have been tested on Xilinx ZynqMP zcu102 board in SD bootmode with images generated by binman. Because u-boot is using CONFIG_POSITION_INDEPENDENT it can be put to others 4k aligned addresses and there is no real need to build it to certain offset.

Quoted 2 lines

Thanks,
Michal

Hello Michal,

Quoted 8 lines
Quoted 5 lines
Quoted 1 line

does this series require changes to doc/uImage.FIT/source_file_format.txt?

I am not changing fit format. I am just changing how SPL records loadables in DT fit-images node. And also series is using FIT functions for reading these properties (at least in this version).

Well I think there should be some mention of the 32/64 bit issue added to the FIT docs. How about adding an example with 64-bit addresses?

git grep "fit-images" doc/
and output is 0. It means we really don't have any documentation for fit-images embed node.
It means we should create one.

/fit-images are related to loadables property that's why I think make sense to document them together.

What about doc/uImage.FIT/howto.txt?

Thanks,
Michal

Do we have any doc which describe

#15 lore raw

cover Add support for loading images above 4GB

Hi Michal,

Quoted 44 lines · Michal Simek

Hi Simon,

Quoted 26 lines · Simon Glass

Hi Michal,

Quoted 23 lines · Michal Simek

Hi,

Quoted 19 lines · Heinrich Schuchardt
Quoted 13 lines · Michal Simek

Hi,

We have several use cases where customers want to partition memory by putting NS images above 4GB. On Xilinx arm 64bit SOC 0-2GB can be used for others CPU in the systems (like R5) or for secure sw. Currently there is limitation in SPL to record load/entry addresses in 64bit format because they are recorded in 32bit only.
This series add support for it.
Patches have been tested on Xilinx ZynqMP zcu102 board in SD bootmode with images generated by binman. Because u-boot is using CONFIG_POSITION_INDEPENDENT it can be put to others 4k aligned addresses and there is no real need to build it to certain offset.

Quoted 2 lines

Thanks,
Michal

Hello Michal,

Quoted 8 lines
Quoted 5 lines
Quoted 1 line

does this series require changes to doc/uImage.FIT/source_file_format.txt?

I am not changing fit format. I am just changing how SPL records loadables in DT fit-images node. And also series is using FIT functions for reading these properties (at least in this version).

Well I think there should be some mention of the 32/64 bit issue added to the FIT docs. How about adding an example with 64-bit addresses?

git grep "fit-images" doc/
and output is 0. It means we really don't have any documentation for fit-images embed node.
It means we should create one.

Quoted 4 lines

/fit-images are related to loadables property that's why I think make sense to document them together.

What about doc/uImage.FIT/howto.txt?

Sounds good.

Regards,
Simon

#16 lore raw

cover Add support for loading images above 4GB

Hi Simon,

Quoted 47 lines · Simon Glass

Hi Michal,

Quoted 44 lines · Michal Simek

Hi Simon,

Quoted 26 lines · Simon Glass

Hi Michal,

Quoted 23 lines · Michal Simek

Hi,

Quoted 19 lines · Heinrich Schuchardt
Quoted 13 lines · Michal Simek

Hi,

We have several use cases where customers want to partition memory by putting NS images above 4GB. On Xilinx arm 64bit SOC 0-2GB can be used for others CPU in the systems (like R5) or for secure sw. Currently there is limitation in SPL to record load/entry addresses in 64bit format because they are recorded in 32bit only.
This series add support for it.
Patches have been tested on Xilinx ZynqMP zcu102 board in SD bootmode with images generated by binman. Because u-boot is using CONFIG_POSITION_INDEPENDENT it can be put to others 4k aligned addresses and there is no real need to build it to certain offset.

Quoted 2 lines

Thanks,
Michal

Hello Michal,

Quoted 8 lines
Quoted 5 lines
Quoted 1 line

does this series require changes to doc/uImage.FIT/source_file_format.txt?

I am not changing fit format. I am just changing how SPL records loadables in DT fit-images node. And also series is using FIT functions for reading these properties (at least in this version).

Well I think there should be some mention of the 32/64 bit issue added to the FIT docs. How about adding an example with 64-bit addresses?

git grep "fit-images" doc/
and output is 0. It means we really don't have any documentation for fit-images embed node.
It means we should create one.

Quoted 6 lines
Quoted 4 lines

/fit-images are related to loadables property that's why I think make sense to document them together.

What about doc/uImage.FIT/howto.txt?

Sounds good.

v2 sent.

Thanks,
Michal