1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2014 Charles Manning <cdhmanning@gmail.com>
5 * Reference doc http://www.altera.com.cn/literature/hb/cyclone-v/cv_5400A.pdf
6 * Note this doc is not entirely accurate. Of particular interest to us is the
7 * "header" length field being in U32s and not bytes.
9 * "Header" is a structure of the following format.
10 * this is positioned at 0x40.
15 * -----------------------
16 * 0x40 4 Validation word 0x31305341
17 * 0x44 1 Version (whatever, zero is fine)
18 * 0x45 1 Flags (unused, zero is fine)
19 * 0x46 2 Length (in units of u32, including the end checksum).
21 * 0x4A 2 Checksum over the header. NB Not CRC32
23 * At the end of the code we have a 32-bit CRC checksum over whole binary
26 * Note that the CRC used here is **not** the zlib/Adler crc32. It is the
27 * CRC-32 used in bzip2, ethernet and elsewhere.
29 * The image is padded out to 64k, because that is what is
30 * typically used to write the image to the boot medium.
33 #include "pbl_crc32.h"
34 #include "imagetool.h"
39 #define HEADER_OFFSET 0x40
40 #define VALIDATION_WORD 0x31305341
41 #define PADDED_SIZE 0x10000
43 /* To allow for adding CRC, the max input size is a bit smaller. */
44 #define MAX_INPUT_SIZE (PADDED_SIZE - sizeof(uint32_t))
46 static uint8_t buffer[PADDED_SIZE];
48 struct socfpga_header {
58 * The header checksum is just a very simple checksum over
60 * There is still a crc32 over the whole lot.
62 static uint16_t hdr_checksum(struct socfpga_header *header)
64 int len = sizeof(*header) - sizeof(header->checksum);
65 uint8_t *buf = (uint8_t *)header;
75 static void build_header(uint8_t *buf, uint8_t version, uint8_t flags,
76 uint16_t length_bytes)
78 struct socfpga_header header;
80 header.validation = cpu_to_le32(VALIDATION_WORD);
81 header.version = version;
83 header.length_u32 = cpu_to_le16(length_bytes/4);
85 header.checksum = cpu_to_le16(hdr_checksum(&header));
87 memcpy(buf, &header, sizeof(header));
91 * Perform a rudimentary verification of header and return
94 static int verify_header(const uint8_t *buf)
96 struct socfpga_header header;
98 memcpy(&header, buf, sizeof(header));
100 if (le32_to_cpu(header.validation) != VALIDATION_WORD)
102 if (le16_to_cpu(header.checksum) != hdr_checksum(&header))
105 return le16_to_cpu(header.length_u32) * 4;
108 /* Sign the buffer and return the signed buffer size */
109 static int sign_buffer(uint8_t *buf,
110 uint8_t version, uint8_t flags,
111 int len, int pad_64k)
115 /* Align the length up */
116 len = (len + 3) & (~3);
118 /* Build header, adding 4 bytes to length to hold the CRC32. */
119 build_header(buf + HEADER_OFFSET, version, flags, len + 4);
121 /* Calculate and apply the CRC */
122 calc_crc = ~pbl_crc32(0, (char *)buf, len);
124 *((uint32_t *)(buf + len)) = cpu_to_le32(calc_crc);
132 /* Verify that the buffer looks sane */
133 static int verify_buffer(const uint8_t *buf)
135 int len; /* Including 32bit CRC */
139 len = verify_header(buf + HEADER_OFFSET);
141 debug("Invalid header\n");
145 if (len < HEADER_OFFSET || len > PADDED_SIZE) {
146 debug("Invalid header length (%i)\n", len);
151 * Adjust length to the base of the CRC.
156 calc_crc = ~pbl_crc32(0, (const char *)buf, len);
158 buf_crc = le32_to_cpu(*((uint32_t *)(buf + len)));
160 if (buf_crc != calc_crc) {
161 fprintf(stderr, "CRC32 does not match (%08x != %08x)\n",
169 /* mkimage glue functions */
170 static int socfpgaimage_verify_header(unsigned char *ptr, int image_size,
171 struct image_tool_params *params)
173 if (image_size != PADDED_SIZE)
176 return verify_buffer(ptr);
179 static void socfpgaimage_print_header(const void *ptr)
181 if (verify_buffer(ptr) == 0)
182 printf("Looks like a sane SOCFPGA preloader\n");
184 printf("Not a sane SOCFPGA preloader\n");
187 static int socfpgaimage_check_params(struct image_tool_params *params)
189 /* Not sure if we should be accepting fflags */
190 return (params->dflag && (params->fflag || params->lflag)) ||
191 (params->fflag && (params->dflag || params->lflag)) ||
192 (params->lflag && (params->dflag || params->fflag));
195 static int socfpgaimage_check_image_types(uint8_t type)
197 if (type == IH_TYPE_SOCFPGAIMAGE)
203 * To work in with the mkimage framework, we do some ugly stuff...
205 * First, socfpgaimage_vrec_header() is called.
206 * We prepend a fake header big enough to make the file PADDED_SIZE.
207 * This gives us enough space to do what we want later.
209 * Next, socfpgaimage_set_header() is called.
210 * We fix up the buffer by moving the image to the start of the buffer.
211 * We now have some room to do what we need (add CRC and padding).
214 static int data_size;
215 #define FAKE_HEADER_SIZE (PADDED_SIZE - data_size)
217 static int socfpgaimage_vrec_header(struct image_tool_params *params,
218 struct image_type_params *tparams)
222 if (params->datafile &&
223 stat(params->datafile, &sbuf) == 0 &&
224 sbuf.st_size <= MAX_INPUT_SIZE) {
225 data_size = sbuf.st_size;
226 tparams->header_size = FAKE_HEADER_SIZE;
231 static void socfpgaimage_set_header(void *ptr, struct stat *sbuf, int ifd,
232 struct image_tool_params *params)
234 uint8_t *buf = (uint8_t *)ptr;
237 * This function is called after vrec_header() has been called.
238 * At this stage we have the FAKE_HEADER_SIZE dummy bytes followed by
239 * data_size image bytes. Total = PADDED_SIZE.
240 * We need to fix the buffer by moving the image bytes back to
241 * the beginning of the buffer, then actually do the signing stuff...
243 memmove(buf, buf + FAKE_HEADER_SIZE, data_size);
244 memset(buf + data_size, 0, FAKE_HEADER_SIZE);
246 sign_buffer(buf, 0, 0, data_size, 0);
251 "Altera SOCFPGA preloader support",
252 0, /* This will be modified by vrec_header() */
254 socfpgaimage_check_params,
255 socfpgaimage_verify_header,
256 socfpgaimage_print_header,
257 socfpgaimage_set_header,
259 socfpgaimage_check_image_types,
261 socfpgaimage_vrec_header