mkexynosspl.c 5.11 KB
Newer Older
1 2 3
/*
 * Copyright (C) 2012 Samsung Electronics
 *
4
 * SPDX-License-Identifier:	GPL-2.0+
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <compiler.h>

#define CHECKSUM_OFFSET		(14*1024-4)
#define FILE_PERM		(S_IRUSR | S_IWUSR | S_IRGRP \
				| S_IWGRP | S_IROTH | S_IWOTH)
/*
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
 * Requirement for the fixed size SPL header:
 * IROM code reads first (CHECKSUM_OFFSET + 4) bytes from boot device. It then
 * calculates the checksum of CHECKSUM_OFFSET bytes and compares with data at
 * CHECKSUM_OFFSET location.
 *
 * Requirement for the variable size SPL header:

 * IROM code reads the below header to find out the size of the blob (total
 * size, header size included) and its checksum. Then it reads the rest of the
 * blob [i.e size - sizeof(struct var_size_header) bytes], calculates the
 * checksum and compares it with value read from the header.
 */
struct var_size_header {
	uint32_t spl_size;
	uint32_t spl_checksum;
	uint32_t reserved[2];
};

static const char *prog_name;

static void write_to_file(int ofd, void *buffer, int size)
{
	if (write(ofd, buffer, size) == size)
		return;

	fprintf(stderr, "%s: Failed to write to output file: %s\n",
		prog_name, strerror(errno));
	exit(EXIT_FAILURE);
}
49

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
/*
 * The argv is expected to include one optional parameter and two filenames:
 * [--vs] IN OUT
 *
 * --vs - turns on the variable size SPL mode
 * IN  - the u-boot SPL binary, usually u-boot-spl.bin
 * OUT - the prepared SPL blob, usually ${BOARD}-spl.bin
 *
 * This utility first reads the "u-boot-spl.bin" into a buffer. In case of
 * fixed size SPL the buffer size is exactly CHECKSUM_OFFSET (such that
 * smaller u-boot-spl.bin gets padded with 0xff bytes, the larger than limit
 * u-boot-spl.bin causes an error). For variable size SPL the buffer size is
 * eqaul to size of the IN file.
 *
 * Then it calculates checksum of the buffer by just summing up all bytes.
 * Then
 *
 * - for fixed size SPL the buffer is written into the output file and the
 *   checksum is appended to the file in little endian format, which results
 *   in checksum added exactly at CHECKSUM_OFFSET.
 *
 * - for variable size SPL the checksum and file size are stored in the
 *   var_size_header structure (again, in little endian format) and the
 *   structure is written into the output file. Then the buffer is written
 *   into the output file.
 */
76 77
int main(int argc, char **argv)
{
78
	unsigned char *buffer;
79 80 81
	int i, ifd, ofd;
	uint32_t checksum = 0;
	off_t	len;
82
	int	var_size_flag, read_size, count;
83
	struct stat stat;
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
	const int if_index = argc - 2; /* Input file name index in argv. */
	const int of_index = argc - 1; /* Output file name index in argv. */

	/* Strip path off the program name. */
	prog_name = strrchr(argv[0], '/');
	if (prog_name)
		prog_name++;
	else
		prog_name = argv[0];

	if ((argc < 3) ||
	    (argc > 4) ||
	    ((argc == 4) && strcmp(argv[1], "--vs"))) {
		fprintf(stderr, "Usage: %s [--vs] <infile> <outfile>\n",
			prog_name);
99 100 101
		exit(EXIT_FAILURE);
	}

102 103 104 105
	/* four args mean variable size SPL wrapper is required */
	var_size_flag = (argc == 4);

	ifd = open(argv[if_index], O_RDONLY);
106 107
	if (ifd < 0) {
		fprintf(stderr, "%s: Can't open %s: %s\n",
108
			prog_name, argv[if_index], strerror(errno));
109 110 111
		exit(EXIT_FAILURE);
	}

112
	ofd = open(argv[of_index], O_WRONLY | O_CREAT | O_TRUNC, FILE_PERM);
113
	if (ofd < 0) {
114
		fprintf(stderr, "%s: Can't open %s: %s\n",
115
			prog_name, argv[of_index], strerror(errno));
116 117 118 119 120
		exit(EXIT_FAILURE);
	}

	if (fstat(ifd, &stat)) {
		fprintf(stderr, "%s: Unable to get size of %s: %s\n",
121
			prog_name, argv[if_index], strerror(errno));
122 123 124 125 126
		exit(EXIT_FAILURE);
	}

	len = stat.st_size;

127 128 129 130 131 132 133 134 135 136 137 138 139
	if (var_size_flag) {
		read_size = len;
		count = len;
	} else {
		if (len > CHECKSUM_OFFSET) {
			fprintf(stderr,
				"%s: %s is too big (exceeds %d bytes)\n",
				prog_name, argv[if_index], CHECKSUM_OFFSET);
			exit(EXIT_FAILURE);
		}
		count = CHECKSUM_OFFSET;
		read_size = len;
	}
140

141 142 143 144 145 146 147
	buffer = malloc(count);
	if (!buffer) {
		fprintf(stderr,
			"%s: Failed to allocate %d bytes to store %s\n",
			prog_name, count, argv[if_index]);
		exit(EXIT_FAILURE);
	}
148

149 150 151
	if (read(ifd, buffer, read_size) != read_size) {
		fprintf(stderr, "%s: Can't read %s: %s\n",
			prog_name, argv[if_index], strerror(errno));
152 153 154
		exit(EXIT_FAILURE);
	}

155 156 157
	/* Pad if needed with 0xff to make flashing faster. */
	if (read_size < count)
		memset((char *)buffer + read_size, 0xff, count - read_size);
158

159 160
	for (i = 0, checksum = 0; i < count; i++)
		checksum += buffer[i];
161 162
	checksum = cpu_to_le32(checksum);

163 164 165 166
	if (var_size_flag) {
		/* Prepare and write out the variable size SPL header. */
		struct var_size_header vsh;
		uint32_t spl_size;
167

168 169
		memset(&vsh, 0, sizeof(vsh));
		memcpy(&vsh.spl_checksum, &checksum, sizeof(checksum));
170

171 172 173
		spl_size = cpu_to_le32(count + sizeof(struct var_size_header));
		memcpy(&vsh.spl_size, &spl_size, sizeof(spl_size));
		write_to_file(ofd, &vsh, sizeof(vsh));
174 175
	}

176 177 178 179 180 181
	write_to_file(ofd, buffer, count);

	/* For fixed size SPL checksum is appended in the end. */
	if (!var_size_flag)
		write_to_file(ofd, &checksum, sizeof(checksum));

182 183
	close(ifd);
	close(ofd);
184
	free(buffer);
185 186 187

	return EXIT_SUCCESS;
}