tools/socfpgaimage.c

   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 );