[J-u-boot.git] / tools / socfpgaimage.c

/*
 * Copyright (C) 2014 Charles Manning <[email protected]>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 *
 * Reference doc http://www.altera.com.cn/literature/hb/cyclone-v/cv_5400A.pdf
 * Note this doc is not entirely accurate. Of particular interest to us is the
 * "header" length field being in U32s and not bytes.
 *
 * "Header" is a structure of the following format.
 * this is positioned at 0x40.
 *
 * Endian is LSB.
 *
 * Offset   Length   Usage
 * -----------------------
 *   0x40        4   Validation word 0x31305341
 *   0x44        1   Version (whatever, zero is fine)
 *   0x45        1   Flags   (unused, zero is fine)
 *   0x46        2   Length  (in units of u32, including the end checksum).
 *   0x48        2   Zero
 *   0x4A        2   Checksum over the header. NB Not CRC32
 *
 * At the end of the code we have a 32-bit CRC checksum over whole binary
 * excluding the CRC.
 *
 * Note that the CRC used here is **not** the zlib/Adler crc32. It is the
 * CRC-32 used in bzip2, ethernet and elsewhere.
 *
 * The image is padded out to 64k, because that is what is
 * typically used to write the image to the boot medium.
 */

#include "pbl_crc32.h"
#include "imagetool.h"
#include "mkimage.h"

#include <image.h>

#define HEADER_OFFSET	0x40
#define VALIDATION_WORD	0x31305341
#define PADDED_SIZE	0x10000

/* To allow for adding CRC, the max input size is a bit smaller. */
#define MAX_INPUT_SIZE	(PADDED_SIZE - sizeof(uint32_t))

static uint8_t buffer[PADDED_SIZE];

static struct socfpga_header {
	uint32_t validation;
	uint8_t  version;
	uint8_t  flags;
	uint16_t length_u32;
	uint16_t zero;
	uint16_t checksum;
} header;

/*
 * The header checksum is just a very simple checksum over
 * the header area.
 * There is still a crc32 over the whole lot.
 */
static uint16_t hdr_checksum(struct socfpga_header *header)
{
	int len = sizeof(*header) - sizeof(header->checksum);
	uint8_t *buf = (uint8_t *)header;
	uint16_t ret = 0;

	while (--len)
		ret += *buf++;

	return ret;
}


static void build_header(uint8_t *buf, uint8_t version, uint8_t flags,
			 uint16_t length_bytes)
{
	header.validation = cpu_to_le32(VALIDATION_WORD);
	header.version = version;
	header.flags = flags;
	header.length_u32 = cpu_to_le16(length_bytes/4);
	header.zero = 0;
	header.checksum = cpu_to_le16(hdr_checksum(&header));

	memcpy(buf, &header, sizeof(header));
}

/*
 * Perform a rudimentary verification of header and return
 * size of image.
 */
static int verify_header(const uint8_t *buf)
{
	memcpy(&header, buf, sizeof(header));

	if (le32_to_cpu(header.validation) != VALIDATION_WORD)
		return -1;
	if (le16_to_cpu(header.checksum) != hdr_checksum(&header))
		return -1;

	return le16_to_cpu(header.length_u32) * 4;
}

/* Sign the buffer and return the signed buffer size */
static int sign_buffer(uint8_t *buf,
			uint8_t version, uint8_t flags,
			int len, int pad_64k)
{
	uint32_t calc_crc;

	/* Align the length up */
	len = (len + 3) & (~3);

	/* Build header, adding 4 bytes to length to hold the CRC32. */
	build_header(buf + HEADER_OFFSET,  version, flags, len + 4);

	/* Calculate and apply the CRC */
	calc_crc = ~pbl_crc32(0, (char *)buf, len);

	*((uint32_t *)(buf + len)) = cpu_to_le32(calc_crc);

	if (!pad_64k)
		return len + 4;

	return PADDED_SIZE;
}

/* Verify that the buffer looks sane */
static int verify_buffer(const uint8_t *buf)
{
	int len; /* Including 32bit CRC */
	uint32_t calc_crc;
	uint32_t buf_crc;

	len = verify_header(buf + HEADER_OFFSET);
	if (len < 0) {
		debug("Invalid header\n");
		return -1;
	}

	if (len < HEADER_OFFSET || len > PADDED_SIZE) {
		debug("Invalid header length (%i)\n", len);
		return -1;
	}

	/*
	 * Adjust length to the base of the CRC.
	 * Check the CRC.
	*/
	len -= 4;

	calc_crc = ~pbl_crc32(0, (const char *)buf, len);

	buf_crc = le32_to_cpu(*((uint32_t *)(buf + len)));

	if (buf_crc != calc_crc) {
		fprintf(stderr, "CRC32 does not match (%08x != %08x)\n",
			buf_crc, calc_crc);
		return -1;
	}

	return 0;
}

/* mkimage glue functions */
static int socfpgaimage_verify_header(unsigned char *ptr, int image_size,
			struct image_tool_params *params)
{
	if (image_size != PADDED_SIZE)
		return -1;

	return verify_buffer(ptr);
}

static void socfpgaimage_print_header(const void *ptr)
{
	if (verify_buffer(ptr) == 0)
		printf("Looks like a sane SOCFPGA preloader\n");
	else
		printf("Not a sane SOCFPGA preloader\n");
}

static int socfpgaimage_check_params(struct image_tool_params *params)
{
	/* Not sure if we should be accepting fflags */
	return	(params->dflag && (params->fflag || params->lflag)) ||
		(params->fflag && (params->dflag || params->lflag)) ||
		(params->lflag && (params->dflag || params->fflag));
}

static int socfpgaimage_check_image_types(uint8_t type)
{
	if (type == IH_TYPE_SOCFPGAIMAGE)
		return EXIT_SUCCESS;
	return EXIT_FAILURE;
}

/*
 * To work in with the mkimage framework, we do some ugly stuff...
 *
 * First, socfpgaimage_vrec_header() is called.
 * We prepend a fake header big enough to make the file PADDED_SIZE.
 * This gives us enough space to do what we want later.
 *
 * Next, socfpgaimage_set_header() is called.
 * We fix up the buffer by moving the image to the start of the buffer.
 * We now have some room to do what we need (add CRC and padding).
 */

static int data_size;
#define FAKE_HEADER_SIZE (PADDED_SIZE - data_size)

static int socfpgaimage_vrec_header(struct image_tool_params *params,
				struct image_type_params *tparams)
{
	struct stat sbuf;

	if (params->datafile &&
	    stat(params->datafile, &sbuf) == 0 &&
	    sbuf.st_size <= MAX_INPUT_SIZE) {
		data_size = sbuf.st_size;
		tparams->header_size = FAKE_HEADER_SIZE;
	}
	return 0;
}

static void socfpgaimage_set_header(void *ptr, struct stat *sbuf, int ifd,
				struct image_tool_params *params)
{
	uint8_t *buf = (uint8_t *)ptr;

	/*
	 * This function is called after vrec_header() has been called.
	 * At this stage we have the FAKE_HEADER_SIZE dummy bytes followed by
	 * data_size image bytes. Total = PADDED_SIZE.
	 * We need to fix the buffer by moving the image bytes back to
	 * the beginning of the buffer, then actually do the signing stuff...
	 */
	memmove(buf, buf + FAKE_HEADER_SIZE, data_size);
	memset(buf + data_size, 0, FAKE_HEADER_SIZE);

	sign_buffer(buf, 0, 0, data_size, 0);
}

U_BOOT_IMAGE_TYPE(
	socfpgaimage,
	"Altera SOCFPGA preloader support",
	0, /* This will be modified by vrec_header() */
	(void *)buffer,
	socfpgaimage_check_params,
	socfpgaimage_verify_header,
	socfpgaimage_print_header,
	socfpgaimage_set_header,
	NULL,
	socfpgaimage_check_image_types,
	NULL,
	socfpgaimage_vrec_header
);
Commit	Line	Data
832472a9 CM	1	/*
	2	* Copyright (C) 2014 Charles Manning <[email protected]>
	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"
26621799 GMF	36	#include "mkimage.h"
26621799 GMF	37
832472a9 CM	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	{
686ed2c2	79	header.validation = cpu_to_le32(VALIDATION_WORD);
832472a9 CM	80	header.version = version;
832472a9 CM	81	header.flags = flags;
686ed2c2	82	header.length_u32 = cpu_to_le16(length_bytes/4);
832472a9	83	header.zero = 0;
686ed2c2	84	header.checksum = cpu_to_le16(hdr_checksum(&header));
832472a9 CM	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
686ed2c2	97	if (le32_to_cpu(header.validation) != VALIDATION_WORD)
832472a9	98	return -1;
686ed2c2	99	if (le16_to_cpu(header.checksum) != hdr_checksum(&header))
832472a9 CM	100	return -1;
832472a9 CM	101
686ed2c2	102	return le16_to_cpu(header.length_u32) * 4;
832472a9 CM	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
686ed2c2	121	((uint32_t )(buf + len)) = cpu_to_le32(calc_crc);
832472a9 CM	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) {
26621799	138	debug("Invalid header\n");
832472a9 CM	139	return -1;
	140	}
	141
	142	if (len < HEADER_OFFSET \|\| len > PADDED_SIZE) {
26621799	143	debug("Invalid header length (%i)\n", len);
832472a9 CM	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
686ed2c2	155	buf_crc = le32_to_cpu(((uint32_t )(buf + len)));
832472a9 CM	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
a93648d1 GMF	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	);