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