Start NOR writer project: copies multi-uimg binaries from SD card to NOR flash

The intended use is for production flashing FSBL+SSBL+App via SD Card
onto NOR flash

Author: danngreen

Makefile

@@ -62,6 +62,10 @@ SOURCES += $(SRCDIR)/gpt/gpt.cc
 endif
 
 
+ifneq ("$(NORFLASH_WRITER)","")
+SOURCES += $(SRCDIR)/boot_sd_write_nor.cc
+endif
+
 INCLUDES = -I. \
 		   -I$(SRCDIR) \
 		   -I$(SRCDIR)/board_conf \
@@ -99,6 +103,10 @@ endif
 endif
 endif
 
+ifneq ("$(NORFLASH_WRITER)","")
+ARCH_CFLAGS += -DNORFLASH_WRITER=1
+endif
+
 AFLAGS = $(MCU)
 
 
@@ -182,10 +190,10 @@ all: Makefile $(ELF) $(UIMAGENAME) image
 	@:
 
 mp13x:
-	$(MAKE) SERIES=stm32mp13x BOARD_CONF=brainboard-mp13_conf.hh
+	$(MAKE) SERIES=stm32mp13x BOARD_CONF=mp133_devboard_v0.3_conf.hh NORFLASH_WRITER=1
 
 mp13x-load:
-	$(MAKE) load SERIES=stm32mp13x BOARD_CONF=brainboard-mp13_conf.hh
+	$(MAKE) load SERIES=stm32mp13x BOARD_CONF=mp133_devboard_v0.3_conf.hh NORFLASH_WRITER=1
 
 $(OBJDIR)/%.o: %.s
 	@mkdir -p $(dir $@)

src/boot_media_loader.hh

@@ -110,7 +110,11 @@ private:
 
 			// Look for entry point in Kernel type images
 			if (type == BootImageDef::IH_TYPE_KERNEL) {
-				if (entry_point >= load_addr && entry_point < (load_addr + size)) {
+				if (load_addr >= 0x60000000 && (load_addr + size) <= 0x90000000) {
+					log("Setting entry point to FMC or QSPI memory: 0x", Hex{entry_point}, "\n");
+					_entry_point = entry_point;
+
+				} else if (entry_point >= load_addr && entry_point < (load_addr + size)) {
 					if (_entry_point.has_value())
 						pr_err("Error: more than one kernel image with a valid entry point found.\n");
 					else {
@@ -195,14 +199,21 @@ private:
 	bool valid_addr(uint64_t addr)
 	{
 #ifdef STM32MP13
-		// TODO: other sectors on MP13?
+		if (addr >= 0x2FFE0000 && addr <= 0x30008000)
+			return true;
+
 #else
 		if (addr >= RETRAM_BASE && addr <= (RETRAM_BASE + STM32MP15x_RETRAM_SIZE))
 			return true;
-#endif
 
 		if (addr >= SRAM_BASE && addr <= (SRAM_BASE + STM32MP15x_SRAM_SIZE))
 			return true;
+#endif
+
+#ifdef NORFLASH_WRITER
+		if (addr >= 0x60000000 && addr <= 0x90000000)
+			return true;
+#endif
 
 		if (addr >= STM32_DDR_BASE && addr <= STM32_DDR_END)
 			return true;

src/boot_sd.hh

@@ -9,6 +9,10 @@
 #include <cstdint>
 #include <span>
 
+#ifdef NORFLASH_WRITER
+#include "boot_sd_write_nor.hh"
+#endif
+
 struct BootSDLoader : BootLoader {
 	BootSDLoader()
 	{
@@ -144,8 +148,10 @@ private:
 			return false;
 		}
 
+		auto load_addr = (uint32_t)data.data();
+
 		debug(" SD read ", data.size(), " bytes from 0x", Hex{address}, "-0x", Hex{address + data.size()});
-		debug(" to 0x", Hex{(uint32_t)data.data()}, "-0x", Hex{(uint32_t)data.data() + data.size()}, "\n");
+		debug(" to 0x", Hex{load_addr}, "-0x", Hex{load_addr + data.size()}, "\n");
 
 		uint32_t aligned_addr = (address / BlockSize) * BlockSize;
 		if (aligned_addr < address) {
@@ -160,8 +166,16 @@ private:
 			debug("  Copying last ", bytes_to_keep, " bytes from tmp to ", Hex{(uint32_t)data.data()}, "\n");
 
 			auto source = std::span<uint8_t>{&tmp[bytes_to_drop], &tmp[512]};
-			for (auto i = 0; auto &d : data.subspan(0, bytes_to_keep))
-				d = source[i++];
+
+#ifdef NORFLASH_WRITER
+			if (load_addr >= 0x6000'0000 && load_addr < 0x9000'0000) {
+				nor_writer.write((uint32_t)data.data(), source);
+			} else
+#endif
+			{
+				for (auto i = 0; auto &d : data.subspan(0, bytes_to_keep))
+					d = source[i++];
+			}
 
 			if (data.size() == bytes_to_keep) {
 				return true;
@@ -191,7 +205,7 @@ private:
 			uint32_t numblocks = bytes_to_read / BlockSize;
 
 			debug("   Reading ", numblocks, " block(s)\n");
-			if (HAL_SD_ReadBlocks(&hsd, read_ptr, block_num, numblocks, timeout) != HAL_OK)
+			if (read_sd_multi_blocks(&hsd, read_ptr, block_num, numblocks, timeout) != HAL_OK)
 				read_error();
 
 			uint32_t bytes_read = numblocks * BlockSize;
@@ -216,15 +230,57 @@ private:
 
 			debug("   Copying first ", bytes_to_copy, " from tmp to ", Hex{uint32_t(read_ptr)}, "\n");
 
-			for (unsigned i = 0; i < bytes_to_copy; i++) {
-				*read_ptr++ = tmp[i];
+#ifdef NORFLASH_WRITER
+			if ((uint32_t)read_ptr >= 0x6000'0000 && (uint32_t)read_ptr < 0x9000'0000) {
+				nor_writer.write((uint32_t)read_ptr, std::span<const uint8_t>{tmp, bytes_to_copy});
+			} else
+#endif
+			{
+				for (unsigned i = 0; i < bytes_to_copy; i++)
+					*read_ptr++ = tmp[i];
 			}
+
 			bytes_to_read -= bytes_to_copy;
 			block_num++;
 		}
 		return true;
 	}
 
+	// Reads entire aligned blocks
+	HAL_StatusTypeDef read_sd_multi_blocks(
+		SD_HandleTypeDef *hsd, uint8_t *read_ptr, uint32_t block_num, uint32_t numblocks, uint32_t timeout)
+	{
+#ifdef NORFLASH_WRITER
+		if ((uint32_t)read_ptr >= 0x6000'0000 && (uint32_t)read_ptr < 0x9000'0000) {
+
+			while (numblocks--) {
+				alignas(4) uint8_t tmp[BlockSize];
+
+				debug("    ", "Reading block #", block_num, " from SD Card to temp memory\n");
+
+				if (auto res = HAL_SD_ReadBlocks(hsd, tmp, block_num, 1, timeout); res == HAL_OK) {
+
+					if (nor_writer.write((uint32_t)read_ptr, tmp)) {
+						debug("Wrote to NOR at 0x", Hex{(uint32_t)read_ptr}, "\n");
+					} else {
+						pr_err("Failed to write SD block #", block_num, " to NOR at 0x", Hex{(uint32_t)read_ptr}, "\n");
+					}
+
+				} else {
+					pr_err("Failed to reading block #", block_num, " from SD Card into temp memory.\n");
+					return res;
+				}
+
+				block_num++;
+				read_ptr += BlockSize;
+			}
+			return HAL_OK;
+
+		} else
+#endif
+			return HAL_SD_ReadBlocks(hsd, read_ptr, block_num, numblocks, timeout);
+	}
+
 	void init_error()
 	{
 		_has_error = true;
@@ -244,4 +300,8 @@ private:
 	}
 
 	constexpr static uint32_t BlockSize = 512;
+
+#ifdef NORFLASH_WRITER
+	NorFlashWriter nor_writer;
+#endif
 };

src/boot_sd_write_nor.cc

@@ -0,0 +1,30 @@
+#include "boot_sd_write_nor.hh"
+#include "print.hh"
+#include "print_messages.hh"
+
+NorFlashWriter::NorFlashWriter() {}
+
+bool NorFlashWriter::write(uint32_t nor_addr, std::span<const uint8_t> bytes)
+{
+	// TODO: skip 0x7008'0000 - 0x40?
+	// It loads the uimg header which could overwrite a previous image
+
+	// Skip out of range addresses
+	if (nor_addr < 0x7000'0000) {
+		bytes = bytes.subspan(0x7000'0000 - nor_addr);
+		nor_addr = 0x7000'0000;
+	}
+
+	debug("Writing to ", Hex{nor_addr}, " ", bytes.size(), " bytes\n");
+
+	// if (nor_addr < 0x7000'0000) {
+	// 	int i = 0;
+	// 	for (auto b : bytes) {
+	// 		print(Hex{b}, " ");
+	// 		i++;
+	// 		if (i % 16 == 0)
+	// 			print("\n");
+	// 	}
+	// }
+	return true;
+}

src/boot_sd_write_nor.hh

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <cstdint>
+#include <span>
+
+struct NorFlashWriter {
+	NorFlashWriter();
+
+	bool write(uint32_t nor_addr, std::span<const uint8_t> bytes);
+};