1 /*
2 * Copyright (c) 2017-2021, STMicroelectronics - All Rights Reserved
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <asm/byteorder.h>
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <stdint.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <sys/mman.h>
15 #include <sys/stat.h>
16 #include <sys/types.h>
17 #include <unistd.h>
18
19 /* Magic = 'S' 'T' 'M' 0x32 */
20 #define HEADER_MAGIC __be32_to_cpu(0x53544D32)
21 #define VER_MAJOR 2
22 #define VER_MINOR 1
23 #define VER_VARIANT 0
24 #define HEADER_VERSION_V1 0x1
25 #define TF_BINARY_TYPE 0x10
26
27 /* Default option : bit0 => no signature */
28 #define HEADER_DEFAULT_OPTION (__cpu_to_le32(0x00000001))
29
30 struct stm32_header {
31 uint32_t magic_number;
32 uint8_t image_signature[64];
33 uint32_t image_checksum;
34 uint8_t header_version[4];
35 uint32_t image_length;
36 uint32_t image_entry_point;
37 uint32_t reserved1;
38 uint32_t load_address;
39 uint32_t reserved2;
40 uint32_t version_number;
41 uint32_t option_flags;
42 uint32_t ecdsa_algorithm;
43 uint8_t ecdsa_public_key[64];
44 uint8_t padding[83];
45 uint8_t binary_type;
46 };
47
stm32image_default_header(struct stm32_header * ptr)48 static void stm32image_default_header(struct stm32_header *ptr)
49 {
50 if (!ptr) {
51 return;
52 }
53
54 ptr->magic_number = HEADER_MAGIC;
55 ptr->option_flags = HEADER_DEFAULT_OPTION;
56 ptr->ecdsa_algorithm = __cpu_to_le32(1);
57 ptr->version_number = __cpu_to_le32(0);
58 ptr->binary_type = TF_BINARY_TYPE;
59 }
60
stm32image_checksum(void * start,uint32_t len)61 static uint32_t stm32image_checksum(void *start, uint32_t len)
62 {
63 uint32_t csum = 0;
64 uint32_t hdr_len = sizeof(struct stm32_header);
65 uint8_t *p;
66
67 if (len < hdr_len) {
68 return 0;
69 }
70
71 p = (unsigned char *)start + hdr_len;
72 len -= hdr_len;
73
74 while (len > 0) {
75 csum += *p;
76 p++;
77 len--;
78 }
79
80 return csum;
81 }
82
stm32image_print_header(const void * ptr)83 static void stm32image_print_header(const void *ptr)
84 {
85 struct stm32_header *stm32hdr = (struct stm32_header *)ptr;
86
87 printf("Image Type : ST Microelectronics STM32 V%d.%d\n",
88 stm32hdr->header_version[VER_MAJOR],
89 stm32hdr->header_version[VER_MINOR]);
90 printf("Image Size : %lu bytes\n",
91 (unsigned long)__le32_to_cpu(stm32hdr->image_length));
92 printf("Image Load : 0x%08x\n",
93 __le32_to_cpu(stm32hdr->load_address));
94 printf("Entry Point : 0x%08x\n",
95 __le32_to_cpu(stm32hdr->image_entry_point));
96 printf("Checksum : 0x%08x\n",
97 __le32_to_cpu(stm32hdr->image_checksum));
98 printf("Option : 0x%08x\n",
99 __le32_to_cpu(stm32hdr->option_flags));
100 printf("Version : 0x%08x\n",
101 __le32_to_cpu(stm32hdr->version_number));
102 }
103
stm32image_set_header(void * ptr,struct stat * sbuf,int ifd,uint32_t loadaddr,uint32_t ep,uint32_t ver,uint32_t major,uint32_t minor)104 static void stm32image_set_header(void *ptr, struct stat *sbuf, int ifd,
105 uint32_t loadaddr, uint32_t ep, uint32_t ver,
106 uint32_t major, uint32_t minor)
107 {
108 struct stm32_header *stm32hdr = (struct stm32_header *)ptr;
109
110 stm32image_default_header(stm32hdr);
111
112 stm32hdr->header_version[VER_MAJOR] = major;
113 stm32hdr->header_version[VER_MINOR] = minor;
114 stm32hdr->load_address = __cpu_to_le32(loadaddr);
115 stm32hdr->image_entry_point = __cpu_to_le32(ep);
116 stm32hdr->image_length = __cpu_to_le32((uint32_t)sbuf->st_size -
117 sizeof(struct stm32_header));
118 stm32hdr->image_checksum =
119 __cpu_to_le32(stm32image_checksum(ptr, sbuf->st_size));
120 stm32hdr->version_number = __cpu_to_le32(ver);
121 }
122
stm32image_create_header_file(char * srcname,char * destname,uint32_t loadaddr,uint32_t entry,uint32_t version,uint32_t major,uint32_t minor)123 static int stm32image_create_header_file(char *srcname, char *destname,
124 uint32_t loadaddr, uint32_t entry,
125 uint32_t version, uint32_t major,
126 uint32_t minor)
127 {
128 int src_fd, dest_fd;
129 struct stat sbuf;
130 unsigned char *ptr;
131 struct stm32_header stm32image_header;
132
133 dest_fd = open(destname, O_RDWR | O_CREAT | O_TRUNC | O_APPEND, 0666);
134 if (dest_fd == -1) {
135 fprintf(stderr, "Can't open %s: %s\n", destname,
136 strerror(errno));
137 return -1;
138 }
139
140 src_fd = open(srcname, O_RDONLY);
141 if (src_fd == -1) {
142 fprintf(stderr, "Can't open %s: %s\n", srcname,
143 strerror(errno));
144 return -1;
145 }
146
147 if (fstat(src_fd, &sbuf) < 0) {
148 return -1;
149 }
150
151 ptr = mmap(NULL, sbuf.st_size, PROT_READ, MAP_SHARED, src_fd, 0);
152 if (ptr == MAP_FAILED) {
153 fprintf(stderr, "Can't read %s\n", srcname);
154 return -1;
155 }
156
157 memset(&stm32image_header, 0, sizeof(struct stm32_header));
158
159 if (write(dest_fd, &stm32image_header, sizeof(struct stm32_header)) !=
160 sizeof(struct stm32_header)) {
161 fprintf(stderr, "Write error %s: %s\n", destname,
162 strerror(errno));
163 return -1;
164 }
165
166 if (write(dest_fd, ptr, sbuf.st_size) != sbuf.st_size) {
167 fprintf(stderr, "Write error on %s: %s\n", destname,
168 strerror(errno));
169 return -1;
170 }
171
172 munmap((void *)ptr, sbuf.st_size);
173 close(src_fd);
174
175 if (fstat(dest_fd, &sbuf) < 0) {
176 return -1;
177 }
178
179 ptr = mmap(0, sbuf.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
180 dest_fd, 0);
181
182 if (ptr == MAP_FAILED) {
183 fprintf(stderr, "Can't write %s\n", destname);
184 return -1;
185 }
186
187 stm32image_set_header(ptr, &sbuf, dest_fd, loadaddr, entry, version,
188 major, minor);
189
190 stm32image_print_header(ptr);
191
192 munmap((void *)ptr, sbuf.st_size);
193 close(dest_fd);
194 return 0;
195 }
196
main(int argc,char * argv[])197 int main(int argc, char *argv[])
198 {
199 int opt, loadaddr = -1, entry = -1, err = 0, version = 0;
200 int major = HEADER_VERSION_V1;
201 int minor = 0;
202 char *dest = NULL, *src = NULL;
203
204 while ((opt = getopt(argc, argv, ":s:d:l:e:v:m:n:")) != -1) {
205 switch (opt) {
206 case 's':
207 src = optarg;
208 break;
209 case 'd':
210 dest = optarg;
211 break;
212 case 'l':
213 loadaddr = strtol(optarg, NULL, 0);
214 break;
215 case 'e':
216 entry = strtol(optarg, NULL, 0);
217 break;
218 case 'v':
219 version = strtol(optarg, NULL, 0);
220 break;
221 case 'm':
222 major = strtol(optarg, NULL, 0);
223 break;
224 case 'n':
225 minor = strtol(optarg, NULL, 0);
226 break;
227 default:
228 fprintf(stderr,
229 "Usage : %s [-s srcfile] [-d destfile] [-l loadaddr] [-e entry_point] [-m major] [-n minor]\n",
230 argv[0]);
231 return -1;
232 }
233 }
234
235 if (!src) {
236 fprintf(stderr, "Missing -s option\n");
237 return -1;
238 }
239
240 if (!dest) {
241 fprintf(stderr, "Missing -d option\n");
242 return -1;
243 }
244
245 if (loadaddr == -1) {
246 fprintf(stderr, "Missing -l option\n");
247 return -1;
248 }
249
250 if (entry == -1) {
251 fprintf(stderr, "Missing -e option\n");
252 return -1;
253 }
254
255 err = stm32image_create_header_file(src, dest, loadaddr,
256 entry, version, major, minor);
257
258 return err;
259 }
260