tools: stm32image: Add support for STM32 Image V2.0
Add support for generating STM32 Image V2.0, which is used by STM32MP13xx.
The image header layout is similar to STM32MP15xx STM32 Image V1.0, but is
different enough to justify duplicate functions to generate the v2 image.
This code at least attempts to align the V1 and V2 image handling where
possible.
Signed-off-by: Marek Vasut <marek.vasut@mailbox.org>
diff --git a/tools/stm32image.c b/tools/stm32image.c
index 5c6991f..2a31d37 100644
--- a/tools/stm32image.c
+++ b/tools/stm32image.c
@@ -8,58 +8,74 @@
/* magic ='S' 'T' 'M' 0x32 */
#define HEADER_MAGIC be32_to_cpu(0x53544D32)
-#define VER_MAJOR_IDX 2
-#define VER_MINOR_IDX 1
-#define VER_VARIANT_IDX 0
+#define VER_MAJOR 2
+#define VER_MINOR 1
+#define VER_VARIANT 0
#define HEADER_VERSION_V1 0x1
+#define HEADER_VERSION_V2 0x2
/* default option : bit0 => no signature */
#define HEADER_DEFAULT_OPTION (cpu_to_le32(0x00000001))
/* default binary type for U-Boot */
#define HEADER_TYPE_UBOOT (cpu_to_le32(0x00000000))
+#define PADDING_HEADER_MAGIC (cpu_to_le32(0xFFFF5453))
+#define PADDING_HEADER_FLAG (1ULL << 31)
+#define PADDING_HEADER_LENGTH 0x180
-struct stm32_header {
+struct stm32_header_v1 {
uint32_t magic_number;
- uint32_t image_signature[64 / 4];
+ uint8_t image_signature[64];
uint32_t image_checksum;
- uint8_t header_version[4];
+ uint8_t header_version[4];
uint32_t image_length;
uint32_t image_entry_point;
uint32_t reserved1;
uint32_t load_address;
uint32_t reserved2;
uint32_t version_number;
+ /* V1.0 specific content */
uint32_t option_flags;
uint32_t ecdsa_algorithm;
- uint32_t ecdsa_public_key[64 / 4];
- uint32_t padding[83 / 4];
- uint32_t binary_type;
+ uint8_t ecdsa_public_key[64];
+ uint8_t padding[83];
+ uint8_t binary_type;
};
-static struct stm32_header stm32image_header;
-
-static void stm32image_default_header(struct stm32_header *ptr)
-{
- if (!ptr)
- return;
+struct stm32_header_v2 {
+ uint32_t magic_number;
+ uint8_t image_signature[64];
+ uint32_t image_checksum;
+ uint8_t header_version[4];
+ uint32_t image_length;
+ uint32_t image_entry_point;
+ uint32_t reserved1;
+ uint32_t load_address;
+ uint32_t reserved2;
+ uint32_t version_number;
+ /* V2.0 specific content */
+ uint32_t extension_flags;
+ uint32_t extension_headers_length;
+ uint32_t binary_type;
+ uint8_t padding[16];
+ uint32_t extension_header_type;
+ uint32_t extension_header_length;
+ uint8_t extension_padding[376];
+};
- ptr->magic_number = HEADER_MAGIC;
- ptr->header_version[VER_MAJOR_IDX] = HEADER_VERSION_V1;
- ptr->option_flags = HEADER_DEFAULT_OPTION;
- ptr->ecdsa_algorithm = cpu_to_le32(1);
- ptr->binary_type = HEADER_TYPE_UBOOT;
-}
+static struct stm32_header_v1 stm32image_header_v1;
+static struct stm32_header_v2 stm32image_header_v2;
-static uint32_t stm32image_checksum(void *start, uint32_t len)
+static uint32_t stm32image_checksum(void *start, uint32_t len,
+ uint32_t header_size)
{
uint32_t csum = 0;
- uint32_t hdr_len = sizeof(struct stm32_header);
uint8_t *p;
- if (len < hdr_len)
+ if (len < header_size) {
return 0;
+ }
- p = start + hdr_len;
- len -= hdr_len;
+ p = (unsigned char *)start + header_size;
+ len -= header_size;
while (len > 0) {
csum += *p;
@@ -70,24 +86,31 @@
return csum;
}
-static int stm32image_check_image_types(uint8_t type)
+static int stm32image_check_image_types_v1(uint8_t type)
{
if (type == IH_TYPE_STM32IMAGE)
return EXIT_SUCCESS;
return EXIT_FAILURE;
}
-static int stm32image_verify_header(unsigned char *ptr, int image_size,
- struct image_tool_params *params)
+static int stm32image_check_image_types_v2(uint8_t type)
{
- struct stm32_header *stm32hdr = (struct stm32_header *)ptr;
+ if (type == IH_TYPE_STM32IMAGE_V2)
+ return EXIT_SUCCESS;
+ return EXIT_FAILURE;
+}
+
+static int stm32image_verify_header_v1(unsigned char *ptr, int image_size,
+ struct image_tool_params *params)
+{
+ struct stm32_header_v1 *stm32hdr = (struct stm32_header_v1 *)ptr;
int i;
- if (image_size < sizeof(struct stm32_header))
+ if (image_size < sizeof(struct stm32_header_v1))
return -1;
if (stm32hdr->magic_number != HEADER_MAGIC)
return -1;
- if (stm32hdr->header_version[VER_MAJOR_IDX] != HEADER_VERSION_V1)
+ if (stm32hdr->header_version[VER_MAJOR] != HEADER_VERSION_V1)
return -1;
if (stm32hdr->reserved1 || stm32hdr->reserved2)
return -1;
@@ -99,40 +122,109 @@
return 0;
}
+static int stm32image_verify_header_v2(unsigned char *ptr, int image_size,
+ struct image_tool_params *params)
+{
+ struct stm32_header_v2 *stm32hdr = (struct stm32_header_v2 *)ptr;
+ int i;
+
+ if (image_size < sizeof(struct stm32_header_v2))
+ return -1;
+ if (stm32hdr->magic_number != HEADER_MAGIC)
+ return -1;
+ if (stm32hdr->header_version[VER_MAJOR] != HEADER_VERSION_V2)
+ return -1;
+ if (stm32hdr->reserved1 || stm32hdr->reserved2)
+ return -1;
+ for (i = 0; i < (sizeof(stm32hdr->padding) / 4); i++) {
+ if (stm32hdr->padding[i] != 0)
+ return -1;
+ }
+
+ return 0;
+}
+
static void stm32image_print_header(const void *ptr, struct image_tool_params *params)
{
- struct stm32_header *stm32hdr = (struct stm32_header *)ptr;
+ struct stm32_header_v1 *stm32hdr_v1 = (struct stm32_header_v1 *)ptr;
+ struct stm32_header_v2 *stm32hdr_v2 = (struct stm32_header_v2 *)ptr;
printf("Image Type : STMicroelectronics STM32 V%d.%d\n",
- stm32hdr->header_version[VER_MAJOR_IDX],
- stm32hdr->header_version[VER_MINOR_IDX]);
+ stm32hdr_v1->header_version[VER_MAJOR],
+ stm32hdr_v1->header_version[VER_MINOR]);
printf("Image Size : %lu bytes\n",
- (unsigned long)le32_to_cpu(stm32hdr->image_length));
+ (unsigned long)le32_to_cpu(stm32hdr_v1->image_length));
printf("Image Load : 0x%08x\n",
- le32_to_cpu(stm32hdr->load_address));
+ le32_to_cpu(stm32hdr_v1->load_address));
printf("Entry Point : 0x%08x\n",
- le32_to_cpu(stm32hdr->image_entry_point));
+ le32_to_cpu(stm32hdr_v1->image_entry_point));
printf("Checksum : 0x%08x\n",
- le32_to_cpu(stm32hdr->image_checksum));
- printf("Option : 0x%08x\n",
- le32_to_cpu(stm32hdr->option_flags));
- printf("BinaryType : 0x%08x\n",
- le32_to_cpu(stm32hdr->binary_type));
+ le32_to_cpu(stm32hdr_v1->image_checksum));
+ switch (stm32hdr_v1->header_version[VER_MAJOR]) {
+ case HEADER_VERSION_V1:
+ printf("Option : 0x%08x\n",
+ le32_to_cpu(stm32hdr_v1->option_flags));
+ printf("BinaryType : 0x%08x\n",
+ le32_to_cpu(stm32hdr_v1->binary_type));
+ break;
+
+ case HEADER_VERSION_V2:
+ printf("Extension : 0x%08x\n",
+ le32_to_cpu(stm32hdr_v2->extension_flags));
+ break;
+
+ default:
+ printf("Incorrect header version\n");
+ }
+}
+
+static void stm32image_set_header_v1(void *ptr, struct stat *sbuf, int ifd,
+ struct image_tool_params *params)
+{
+ struct stm32_header_v1 *stm32hdr = (struct stm32_header_v1 *)ptr;
+
+ stm32hdr->magic_number = HEADER_MAGIC;
+ stm32hdr->version_number = cpu_to_le32(0);
+
+ stm32hdr->header_version[VER_MAJOR] = HEADER_VERSION_V1;
+ stm32hdr->option_flags = HEADER_DEFAULT_OPTION;
+ stm32hdr->ecdsa_algorithm = cpu_to_le32(1);
+ stm32hdr->binary_type = HEADER_TYPE_UBOOT;
+
+ stm32hdr->load_address = cpu_to_le32(params->addr);
+ stm32hdr->image_entry_point = cpu_to_le32(params->ep);
+ stm32hdr->image_length = cpu_to_le32((uint32_t)sbuf->st_size -
+ sizeof(*stm32hdr));
+ stm32hdr->image_checksum =
+ cpu_to_le32(stm32image_checksum(ptr, sbuf->st_size,
+ sizeof(*stm32hdr)));
}
-static void stm32image_set_header(void *ptr, struct stat *sbuf, int ifd,
- struct image_tool_params *params)
+static void stm32image_set_header_v2(void *ptr, struct stat *sbuf, int ifd,
+ struct image_tool_params *params)
{
- struct stm32_header *stm32hdr = (struct stm32_header *)ptr;
+ struct stm32_header_v2 *stm32hdr = (struct stm32_header_v2 *)ptr;
- stm32image_default_header(stm32hdr);
+ stm32hdr->magic_number = HEADER_MAGIC;
+ stm32hdr->version_number = cpu_to_le32(0);
+
+ stm32hdr->header_version[VER_MAJOR] = HEADER_VERSION_V2;
+ stm32hdr->extension_flags =
+ cpu_to_le32(PADDING_HEADER_FLAG);
+ stm32hdr->extension_headers_length =
+ cpu_to_le32(PADDING_HEADER_LENGTH);
+ stm32hdr->extension_header_type =
+ cpu_to_le32(PADDING_HEADER_MAGIC);
+ stm32hdr->extension_header_length =
+ cpu_to_le32(PADDING_HEADER_LENGTH);
stm32hdr->load_address = cpu_to_le32(params->addr);
stm32hdr->image_entry_point = cpu_to_le32(params->ep);
stm32hdr->image_length = cpu_to_le32((uint32_t)sbuf->st_size -
- sizeof(struct stm32_header));
+ sizeof(*stm32hdr));
stm32hdr->image_checksum =
- cpu_to_le32(stm32image_checksum(ptr, sbuf->st_size));
+ cpu_to_le32(stm32image_checksum(ptr, sbuf->st_size,
+ sizeof(*stm32hdr)));
}
/*
@@ -141,14 +233,29 @@
U_BOOT_IMAGE_TYPE(
stm32image,
"STMicroelectronics STM32MP Image support",
- sizeof(struct stm32_header),
- (void *)&stm32image_header,
+ sizeof(struct stm32_header_v1),
+ (void *)&stm32image_header_v1,
+ NULL,
+ stm32image_verify_header_v1,
+ stm32image_print_header,
+ stm32image_set_header_v1,
+ NULL,
+ stm32image_check_image_types_v1,
NULL,
- stm32image_verify_header,
+ NULL
+);
+
+U_BOOT_IMAGE_TYPE(
+ stm32imagev2,
+ "STMicroelectronics STM32MP Image V2.0 support",
+ sizeof(struct stm32_header_v2),
+ (void *)&stm32image_header_v2,
+ NULL,
+ stm32image_verify_header_v2,
stm32image_print_header,
- stm32image_set_header,
+ stm32image_set_header_v2,
NULL,
- stm32image_check_image_types,
+ stm32image_check_image_types_v2,
NULL,
NULL
);