xref: /openbmc/u-boot/tools/socfpgaimage.c (revision ebce73f0)
1 /*
2  * Copyright (C) 2014 Charles Manning <cdhmanning@gmail.com>
3  *
4  * SPDX-License-Identifier:	GPL-2.0+
5  *
6  * Reference doc http://www.altera.com.cn/literature/hb/cyclone-v/cv_5400A.pdf
7  * Note this doc is not entirely accurate. Of particular interest to us is the
8  * "header" length field being in U32s and not bytes.
9  *
10  * "Header" is a structure of the following format.
11  * this is positioned at 0x40.
12  *
13  * Endian is LSB.
14  *
15  * Offset   Length   Usage
16  * -----------------------
17  *   0x40        4   Validation word 0x31305341
18  *   0x44        1   Version (whatever, zero is fine)
19  *   0x45        1   Flags   (unused, zero is fine)
20  *   0x46        2   Length  (in units of u32, including the end checksum).
21  *   0x48        2   Zero
22  *   0x4A        2   Checksum over the header. NB Not CRC32
23  *
24  * At the end of the code we have a 32-bit CRC checksum over whole binary
25  * excluding the CRC.
26  *
27  * Note that the CRC used here is **not** the zlib/Adler crc32. It is the
28  * CRC-32 used in bzip2, ethernet and elsewhere.
29  *
30  * The image is padded out to 64k, because that is what is
31  * typically used to write the image to the boot medium.
32  */
33 
34 #include "pbl_crc32.h"
35 #include "imagetool.h"
36 #include "mkimage.h"
37 
38 #include <image.h>
39 
40 #define HEADER_OFFSET	0x40
41 #define VALIDATION_WORD	0x31305341
42 #define PADDED_SIZE	0x10000
43 
44 /* To allow for adding CRC, the max input size is a bit smaller. */
45 #define MAX_INPUT_SIZE	(PADDED_SIZE - sizeof(uint32_t))
46 
47 static uint8_t buffer[PADDED_SIZE];
48 
49 static struct socfpga_header {
50 	uint32_t validation;
51 	uint8_t  version;
52 	uint8_t  flags;
53 	uint16_t length_u32;
54 	uint16_t zero;
55 	uint16_t checksum;
56 } header;
57 
58 /*
59  * The header checksum is just a very simple checksum over
60  * the header area.
61  * There is still a crc32 over the whole lot.
62  */
63 static uint16_t hdr_checksum(struct socfpga_header *header)
64 {
65 	int len = sizeof(*header) - sizeof(header->checksum);
66 	uint8_t *buf = (uint8_t *)header;
67 	uint16_t ret = 0;
68 
69 	while (--len)
70 		ret += *buf++;
71 
72 	return ret;
73 }
74 
75 
76 static void build_header(uint8_t *buf, uint8_t version, uint8_t flags,
77 			 uint16_t length_bytes)
78 {
79 	header.validation = cpu_to_le32(VALIDATION_WORD);
80 	header.version = version;
81 	header.flags = flags;
82 	header.length_u32 = cpu_to_le16(length_bytes/4);
83 	header.zero = 0;
84 	header.checksum = cpu_to_le16(hdr_checksum(&header));
85 
86 	memcpy(buf, &header, sizeof(header));
87 }
88 
89 /*
90  * Perform a rudimentary verification of header and return
91  * size of image.
92  */
93 static int verify_header(const uint8_t *buf)
94 {
95 	memcpy(&header, buf, sizeof(header));
96 
97 	if (le32_to_cpu(header.validation) != VALIDATION_WORD)
98 		return -1;
99 	if (le16_to_cpu(header.checksum) != hdr_checksum(&header))
100 		return -1;
101 
102 	return le16_to_cpu(header.length_u32) * 4;
103 }
104 
105 /* Sign the buffer and return the signed buffer size */
106 static int sign_buffer(uint8_t *buf,
107 			uint8_t version, uint8_t flags,
108 			int len, int pad_64k)
109 {
110 	uint32_t calc_crc;
111 
112 	/* Align the length up */
113 	len = (len + 3) & (~3);
114 
115 	/* Build header, adding 4 bytes to length to hold the CRC32. */
116 	build_header(buf + HEADER_OFFSET,  version, flags, len + 4);
117 
118 	/* Calculate and apply the CRC */
119 	calc_crc = ~pbl_crc32(0, (char *)buf, len);
120 
121 	*((uint32_t *)(buf + len)) = cpu_to_le32(calc_crc);
122 
123 	if (!pad_64k)
124 		return len + 4;
125 
126 	return PADDED_SIZE;
127 }
128 
129 /* Verify that the buffer looks sane */
130 static int verify_buffer(const uint8_t *buf)
131 {
132 	int len; /* Including 32bit CRC */
133 	uint32_t calc_crc;
134 	uint32_t buf_crc;
135 
136 	len = verify_header(buf + HEADER_OFFSET);
137 	if (len < 0) {
138 		debug("Invalid header\n");
139 		return -1;
140 	}
141 
142 	if (len < HEADER_OFFSET || len > PADDED_SIZE) {
143 		debug("Invalid header length (%i)\n", len);
144 		return -1;
145 	}
146 
147 	/*
148 	 * Adjust length to the base of the CRC.
149 	 * Check the CRC.
150 	*/
151 	len -= 4;
152 
153 	calc_crc = ~pbl_crc32(0, (const char *)buf, len);
154 
155 	buf_crc = le32_to_cpu(*((uint32_t *)(buf + len)));
156 
157 	if (buf_crc != calc_crc) {
158 		fprintf(stderr, "CRC32 does not match (%08x != %08x)\n",
159 			buf_crc, calc_crc);
160 		return -1;
161 	}
162 
163 	return 0;
164 }
165 
166 /* mkimage glue functions */
167 static int socfpgaimage_verify_header(unsigned char *ptr, int image_size,
168 			struct image_tool_params *params)
169 {
170 	if (image_size != PADDED_SIZE)
171 		return -1;
172 
173 	return verify_buffer(ptr);
174 }
175 
176 static void socfpgaimage_print_header(const void *ptr)
177 {
178 	if (verify_buffer(ptr) == 0)
179 		printf("Looks like a sane SOCFPGA preloader\n");
180 	else
181 		printf("Not a sane SOCFPGA preloader\n");
182 }
183 
184 static int socfpgaimage_check_params(struct image_tool_params *params)
185 {
186 	/* Not sure if we should be accepting fflags */
187 	return	(params->dflag && (params->fflag || params->lflag)) ||
188 		(params->fflag && (params->dflag || params->lflag)) ||
189 		(params->lflag && (params->dflag || params->fflag));
190 }
191 
192 static int socfpgaimage_check_image_types(uint8_t type)
193 {
194 	if (type == IH_TYPE_SOCFPGAIMAGE)
195 		return EXIT_SUCCESS;
196 	return EXIT_FAILURE;
197 }
198 
199 /*
200  * To work in with the mkimage framework, we do some ugly stuff...
201  *
202  * First, socfpgaimage_vrec_header() is called.
203  * We prepend a fake header big enough to make the file PADDED_SIZE.
204  * This gives us enough space to do what we want later.
205  *
206  * Next, socfpgaimage_set_header() is called.
207  * We fix up the buffer by moving the image to the start of the buffer.
208  * We now have some room to do what we need (add CRC and padding).
209  */
210 
211 static int data_size;
212 #define FAKE_HEADER_SIZE (PADDED_SIZE - data_size)
213 
214 static int socfpgaimage_vrec_header(struct image_tool_params *params,
215 				struct image_type_params *tparams)
216 {
217 	struct stat sbuf;
218 
219 	if (params->datafile &&
220 	    stat(params->datafile, &sbuf) == 0 &&
221 	    sbuf.st_size <= MAX_INPUT_SIZE) {
222 		data_size = sbuf.st_size;
223 		tparams->header_size = FAKE_HEADER_SIZE;
224 	}
225 	return 0;
226 }
227 
228 static void socfpgaimage_set_header(void *ptr, struct stat *sbuf, int ifd,
229 				struct image_tool_params *params)
230 {
231 	uint8_t *buf = (uint8_t *)ptr;
232 
233 	/*
234 	 * This function is called after vrec_header() has been called.
235 	 * At this stage we have the FAKE_HEADER_SIZE dummy bytes followed by
236 	 * data_size image bytes. Total = PADDED_SIZE.
237 	 * We need to fix the buffer by moving the image bytes back to
238 	 * the beginning of the buffer, then actually do the signing stuff...
239 	 */
240 	memmove(buf, buf + FAKE_HEADER_SIZE, data_size);
241 	memset(buf + data_size, 0, FAKE_HEADER_SIZE);
242 
243 	sign_buffer(buf, 0, 0, data_size, 0);
244 }
245 
246 U_BOOT_IMAGE_TYPE(
247 	socfpgaimage,
248 	"Altera SOCFPGA preloader support",
249 	0, /* This will be modified by vrec_header() */
250 	(void *)buffer,
251 	socfpgaimage_check_params,
252 	socfpgaimage_verify_header,
253 	socfpgaimage_print_header,
254 	socfpgaimage_set_header,
255 	NULL,
256 	socfpgaimage_check_image_types,
257 	NULL,
258 	socfpgaimage_vrec_header
259 );
260