[PATCH 1/2] tools: mkimage: add SpacemiT K3 AIHD image support

The SpacemiT BootROM loads the FSBL from an AIHD image: a fixed 4 KiB
header with two metadata headers and authentication information, followed
by a 32-byte-aligned SPL payload and a trailing authentication area. K1
and K3 share the same layout, but use different integrity and
authentication schemes. K1 requires RSA-signed images, while K3 uses
CRC32 to verify images in non-secure boot mode.

Add mkimage type "aihdimage" for the K3 CRC32 path. Populate both
metadata headers, fill their CRC32 values and the payload CRC32, and
reserve the authentication areas required by the layout. Only "-n k3" is
wired up so far, but SoC differences already go through a variant table
so K1 RSA signing can be added later.

The AIHD header has no reliable K1/K3 identifier, so the SoC is selected
with -n. dumpimage is omitted for the same reason: it cannot take -n and
therefore cannot differentiate between the two variants.

Only support for non-secure boot mode on the K3 SoC is implemented in
this patch. K1 support and the RSA authentication scheme can be added
later.

Signed-off-by: Junhui Liu <[email protected]>
---
 boot/image.c      |   1 +
 include/image.h   |   1 +
 tools/Makefile    |   3 +-
 tools/aihdimage.c | 202 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 206 insertions(+), 1 deletion(-)

diff --git a/boot/image.c b/boot/image.c
index 185d52ba492f..8dbfb677e631 100644
--- a/boot/image.c
+++ b/boot/image.c
@@ -179,6 +179,7 @@ static const table_entry_t uimage_type[] = {
 	{	IH_TYPE_TFA_BL31, "tfa-bl31",  "TFA BL31 Image", },
 	{	IH_TYPE_STM32IMAGE_V2, "stm32imagev2", "STMicroelectronics STM32 Image V2.0" },
 	{	IH_TYPE_AMLIMAGE,   "amlimage",   "Amlogic Boot Image" },
+	{	IH_TYPE_AIHDIMAGE, "aihdimage", "SpacemiT AIHD Boot Image" },
 	{	-1,		    "",		  "",			},
 };
 
diff --git a/include/image.h b/include/image.h
index 6edcb1995bfe..7d101960cac6 100644
--- a/include/image.h
+++ b/include/image.h
@@ -235,6 +235,7 @@ enum image_type_t {
 	IH_TYPE_TFA_BL31,		/* TFA BL31 image */
 	IH_TYPE_STM32IMAGE_V2,		/* STMicroelectronics STM32 Image V2.0 */
 	IH_TYPE_AMLIMAGE,		/* Amlogic Boot Image */
+	IH_TYPE_AIHDIMAGE,		/* SpacemiT AIHD Boot Image */
 
 	IH_TYPE_COUNT,			/* Number of image types */
 };
diff --git a/tools/Makefile b/tools/Makefile
index 535a5d51c89e..e838e16e0f05 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -110,7 +110,8 @@ KWB_IMAGE_OBJS-$(CONFIG_TOOLS_LIBCRYPTO) := kwbimage.o
 ROCKCHIP_OBS = generated/lib/rc4.o rkcommon.o rkimage.o rksd.o rkspi.o
 
 # common objs for dumpimage and mkimage
-dumpimage-mkimage-objs := aisimage.o \
+dumpimage-mkimage-objs := aihdimage.o \
+			aisimage.o \
 			amlimage.o \
 			atmelimage.o \
 			$(FIT_OBJS-y) \
diff --git a/tools/aihdimage.c b/tools/aihdimage.c
new file mode 100644
index 000000000000..e4e9ecdd97d9
--- /dev/null
+++ b/tools/aihdimage.c
@@ -0,0 +1,202 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2026 Junhui Liu <[email protected]>
+ *
+ * The SpacemiT AIHD boot image consists of a fixed image header followed by an
+ * aligned SPL payload and a trailing authentication area. The image header
+ * contains two metadata headers and areas reserved for authentication data.
+ *
+ * The image layout is:
+ *
+ *   0x000             root key
+ *   0x100             header0
+ *   0x120             key metadata
+ *   0x300             OEM keys
+ *   0xb00             signature0
+ *   0xfe0             header1
+ *   0x1000            SPL payload, with its end aligned to 32 bytes
+ *   payload end       signature1 (0x100 bytes)
+ */
+
+#include <image.h>
+#include <u-boot/crc.h>
+#include "imagetool.h"
+
+#define AIHD_MAGIC		"AIHD"
+#define AIHD_PAYLOAD_ALIGN	32
+#define AIHD_AUTH_SIZE		0x100
+
+#define AIHD_FLAG_CRC32		(1U << 0)
+
+/**
+ * struct aihdimage_header - metadata header within an AIHD image header
+ *
+ * @magic:	Magic (must be AIHD_MAGIC)
+ * @version:	Image version used when anti-rollback is enabled by eFuse
+ * @secure:	Version slot used when anti-rollback is enabled by eFuse
+ * @reserved:	Reserved
+ * @image_size:	Header0 stores the image header size
+ *		Header1 stores the aligned payload size
+ * @load_addr:	Unused
+ * @header_crc:	Header0 and Header1 store the CRC32 of the preceding 24 bytes on K3
+ * @image_crc:	Header1 stores the CRC32 of the aligned payload on K3
+ */
+struct aihdimage_header {
+	uint8_t magic[4];
+	uint8_t version;
+	uint8_t secure;
+	uint16_t reserved;
+	uint64_t image_size;
+	uint64_t load_addr;
+	uint32_t header_crc;
+	uint32_t image_crc;
+} __packed;
+
+/**
+ * struct aihdimage_image_header - fixed header area of an AIHD image
+ *
+ * @root_key:	Root public key
+ * @header0:	Image layout and load information
+ * @key_data:	Key metadata
+ * @oem_keys:	OEM public-key area
+ * @signature0:	Signature of the image configuration
+ * @reserved:	Reserved
+ * @header1:	SPL payload information
+ */
+struct aihdimage_image_header {
+	uint8_t root_key[0x100];
+	struct aihdimage_header header0;
+	uint8_t key_data[0x1e0];
+	uint8_t oem_keys[0x800];
+	uint8_t signature0[AIHD_AUTH_SIZE];
+	uint8_t reserved[0x3e0];
+	struct aihdimage_header header1;
+} __packed;
+
+/**
+ * struct aihdimage_variant - SoC-specific AIHD properties
+ *
+ * @name:	SoC name passed to mkimage with -n
+ * @flags:	SoC-specific AIHD flags
+ */
+struct aihdimage_variant {
+	const char *name;
+	unsigned int flags;
+};
+
+static const struct aihdimage_variant aihdimage_variants[] = {
+	{
+		.name = "k3",
+		.flags = AIHD_FLAG_CRC32,
+	},
+};
+
+static const struct aihdimage_variant *aihdimage_get_variant(const char *name)
+{
+	int i;
+
+	if (!name || !*name)
+		return NULL;
+
+	for (i = 0; i < ARRAY_SIZE(aihdimage_variants); i++)
+		if (!strcmp(name, aihdimage_variants[i].name))
+			return &aihdimage_variants[i];
+
+	return NULL;
+}
+
+static void aihdimage_init_header(struct aihdimage_header *header, uint64_t image_size,
+				  const struct aihdimage_variant *variant)
+{
+	uint32_t crc;
+
+	memcpy(header->magic, AIHD_MAGIC, sizeof(header->magic));
+
+	header->image_size = cpu_to_le64(image_size);
+
+	if (variant->flags & AIHD_FLAG_CRC32) {
+		crc = crc32(0, (uint8_t *)header,
+			    offsetof(struct aihdimage_header, header_crc));
+		header->header_crc = cpu_to_le32(crc);
+	}
+}
+
+static int aihdimage_check_params(struct image_tool_params *params)
+{
+	if (!aihdimage_get_variant(params->imagename)) {
+		fprintf(stderr, "%s: SpacemiT SoC must be specified with -n\n",
+			params->cmdname);
+		return EXIT_FAILURE;
+	}
+
+	if (!params->dflag)
+		return EXIT_FAILURE;
+
+	return EXIT_SUCCESS;
+}
+
+static void aihdimage_print_header(const void *buf, struct image_tool_params *params)
+{
+	const struct aihdimage_image_header *image_header = buf;
+	const struct aihdimage_header *header1 = &image_header->header1;
+	uint64_t payload_size = le64_to_cpu(header1->image_size);
+
+	printf("SpacemiT AIHD Boot Image (%s)\n", params->imagename);
+	printf("Total Size: %llu bytes\n",
+	       (unsigned long long)(sizeof(*image_header) + payload_size + AIHD_AUTH_SIZE));
+	printf("Payload Size: %llu bytes\n", (unsigned long long)payload_size);
+}
+
+static void aihdimage_set_header(void *buf, struct stat *sbuf, int infd,
+				 struct image_tool_params *params)
+{
+	const struct aihdimage_variant *variant = aihdimage_get_variant(params->imagename);
+	struct aihdimage_image_header *image_header = buf;
+	struct aihdimage_header *header0 = &image_header->header0;
+	struct aihdimage_header *header1 = &image_header->header1;
+	size_t payload_size;
+	uint32_t crc;
+
+	payload_size = sbuf->st_size - sizeof(*image_header) - AIHD_AUTH_SIZE;
+
+	aihdimage_init_header(header0, sizeof(*image_header), variant);
+	aihdimage_init_header(header1, payload_size, variant);
+
+	if (variant->flags & AIHD_FLAG_CRC32) {
+		crc = crc32(0, (uint8_t *)(image_header + 1), payload_size);
+		header1->image_crc = cpu_to_le32(crc);
+	}
+}
+
+static int aihdimage_check_image_type(uint8_t type)
+{
+	if (type == IH_TYPE_AIHDIMAGE)
+		return EXIT_SUCCESS;
+
+	return EXIT_FAILURE;
+}
+
+static int aihdimage_vrec_header(struct image_tool_params *params,
+				 struct image_type_params *tparams)
+{
+	size_t payload_size = params->file_size - tparams->header_size;
+
+	tparams->hdr = calloc(tparams->header_size, 1);
+
+	return ALIGN(payload_size, AIHD_PAYLOAD_ALIGN) - payload_size + AIHD_AUTH_SIZE;
+}
+
+U_BOOT_IMAGE_TYPE(
+	aihdimage,
+	"SpacemiT AIHD Boot Image support",
+	sizeof(struct aihdimage_image_header),
+	NULL,
+	aihdimage_check_params,
+	NULL,
+	aihdimage_print_header,
+	aihdimage_set_header,
+	NULL,
+	aihdimage_check_image_type,
+	NULL,
+	aihdimage_vrec_header
+);

-- 
2.55.0