SPL: EXYNOS: Prepare for variable size SPL support
When variable size SPL is used, the BL1 expects the SPL to be encapsulated differently: instead of putting the checksum at a fixed offset in the SPL blob, prepend the blob with a header including the size and the checksum. The enhancements include - adding a command line option, '--vs' to indicate the need for the variable size encapsulation - padding the fixed size encapsulated blob with 0xff instead of random memory contents - do not silently truncate the input file, report error instead - no need to explicitly closing files/freeing memory, this all happens on exit; removing cleanups it makes code clearer - profuse commenting - modify Makefile to allow enabling the new feature per board Signed-off-by: Vadim Bendebury <vbendeb@chromium.org> Signed-off-by: Rajeshwari S Shinde <rajeshwari.s@samsung.com> Acked-by: Simon Glass <sjg@chromium.org> Signed-off-by: Minkyu Kang <mk7.kang@samsung.com>
This commit is contained in:
Rajeshwari Birje
Minkyu Kang
parent
76dd9b6a63
commit
0fcac1abde
@ -19,6 +19,8 @@
|
||||
|
||||
#define CONFIG_ARCH_DEVICE_TREE exynos5420
|
||||
|
||||
#define CONFIG_VAR_SIZE_SPL
|
||||
|
||||
#define CONFIG_SYS_SDRAM_BASE 0x20000000
|
||||
#define CONFIG_SYS_TEXT_BASE 0x23E00000
|
||||
|
||||
@ -31,7 +33,11 @@
|
||||
/* select serial console configuration */
|
||||
#define CONFIG_SERIAL3 /* use SERIAL 3 */
|
||||
|
||||
#ifdef CONFIG_VAR_SIZE_SPL
|
||||
#define CONFIG_SPL_TEXT_BASE 0x02024410
|
||||
#else
|
||||
#define CONFIG_SPL_TEXT_BASE 0x02024400
|
||||
#endif
|
||||
|
||||
#define CONFIG_BOOTCOMMAND "mmc read 20007000 451 2000; bootm 20007000"
|
||||
|
||||
|
||||
@ -166,8 +166,13 @@ endif
|
||||
all: $(ALL-y)
|
||||
|
||||
ifdef CONFIG_SAMSUNG
|
||||
ifdef CONFIG_VAR_SIZE_SPL
|
||||
VAR_SIZE_PARAM = --vs
|
||||
else
|
||||
VAR_SIZE_PARAM =
|
||||
endif
|
||||
$(obj)$(BOARD)-spl.bin: $(obj)u-boot-spl.bin
|
||||
$(OBJTREE)/tools/mk$(BOARD)spl $< $@
|
||||
$(OBJTREE)/tools/mk$(BOARD)spl $(VAR_SIZE_PARAM) $< $@
|
||||
endif
|
||||
|
||||
$(obj)$(SPL_BIN).bin: $(obj)$(SPL_BIN)
|
||||
|
||||
@ -14,93 +14,174 @@
|
||||
#include <compiler.h>
|
||||
|
||||
#define CHECKSUM_OFFSET (14*1024-4)
|
||||
#define BUFSIZE (14*1024)
|
||||
#define FILE_PERM (S_IRUSR | S_IWUSR | S_IRGRP \
|
||||
| S_IWGRP | S_IROTH | S_IWOTH)
|
||||
/*
|
||||
* Requirement:
|
||||
* IROM code reads first 14K bytes from boot device.
|
||||
* It then calculates the checksum of 14K-4 bytes and compare with data at
|
||||
* 14K-4 offset.
|
||||
*
|
||||
* This function takes two filenames:
|
||||
* IN "u-boot-spl.bin" and
|
||||
* OUT "$(BOARD)-spl.bin as filenames.
|
||||
* It reads the "u-boot-spl.bin" in 16K buffer.
|
||||
* It calculates checksum of 14K-4 Bytes and stores at 14K-4 offset in buffer.
|
||||
* It writes the buffer to "$(BOARD)-spl.bin" file.
|
||||
*/
|
||||
* 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);
|
||||
}
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
unsigned char buffer[BUFSIZE];
|
||||
unsigned char *buffer;
|
||||
int i, ifd, ofd;
|
||||
uint32_t checksum = 0;
|
||||
off_t len;
|
||||
ssize_t count;
|
||||
int var_size_flag, read_size, count;
|
||||
struct stat stat;
|
||||
const int if_index = argc - 2; /* Input file name index in argv. */
|
||||
const int of_index = argc - 1; /* Output file name index in argv. */
|
||||
|
||||
if (argc != 3) {
|
||||
fprintf(stderr, "Usage: %s <infile> <outfile>\n", argv[0]);
|
||||
/* 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);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
ifd = open(argv[1], O_RDONLY);
|
||||
/* four args mean variable size SPL wrapper is required */
|
||||
var_size_flag = (argc == 4);
|
||||
|
||||
ifd = open(argv[if_index], O_RDONLY);
|
||||
if (ifd < 0) {
|
||||
fprintf(stderr, "%s: Can't open %s: %s\n",
|
||||
argv[0], argv[1], strerror(errno));
|
||||
prog_name, argv[if_index], strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
ofd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, FILE_PERM);
|
||||
ofd = open(argv[of_index], O_WRONLY | O_CREAT | O_TRUNC, FILE_PERM);
|
||||
if (ifd < 0) {
|
||||
fprintf(stderr, "%s: Can't open %s: %s\n",
|
||||
argv[0], argv[2], strerror(errno));
|
||||
close(ifd);
|
||||
prog_name, argv[of_index], strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (fstat(ifd, &stat)) {
|
||||
fprintf(stderr, "%s: Unable to get size of %s: %s\n",
|
||||
argv[0], argv[1], strerror(errno));
|
||||
close(ifd);
|
||||
close(ofd);
|
||||
prog_name, argv[if_index], strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
len = stat.st_size;
|
||||
|
||||
count = (len < CHECKSUM_OFFSET) ? len : CHECKSUM_OFFSET;
|
||||
|
||||
if (read(ifd, buffer, count) != count) {
|
||||
fprintf(stderr, "%s: Can't read %s: %s\n",
|
||||
argv[0], argv[1], strerror(errno));
|
||||
|
||||
close(ifd);
|
||||
close(ofd);
|
||||
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;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
for (i = 0, checksum = 0; i < CHECKSUM_OFFSET; i++)
|
||||
checksum += buffer[i];
|
||||
if (read(ifd, buffer, read_size) != read_size) {
|
||||
fprintf(stderr, "%s: Can't read %s: %s\n",
|
||||
prog_name, argv[if_index], strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* Pad if needed with 0xff to make flashing faster. */
|
||||
if (read_size < count)
|
||||
memset((char *)buffer + read_size, 0xff, count - read_size);
|
||||
|
||||
for (i = 0, checksum = 0; i < count; i++)
|
||||
checksum += buffer[i];
|
||||
checksum = cpu_to_le32(checksum);
|
||||
|
||||
memcpy(&buffer[CHECKSUM_OFFSET], &checksum, sizeof(checksum));
|
||||
if (var_size_flag) {
|
||||
/* Prepare and write out the variable size SPL header. */
|
||||
struct var_size_header vsh;
|
||||
uint32_t spl_size;
|
||||
|
||||
if (write(ofd, buffer, BUFSIZE) != BUFSIZE) {
|
||||
fprintf(stderr, "%s: Can't write %s: %s\n",
|
||||
argv[0], argv[2], strerror(errno));
|
||||
memset(&vsh, 0, sizeof(vsh));
|
||||
memcpy(&vsh.spl_checksum, &checksum, sizeof(checksum));
|
||||
|
||||
close(ifd);
|
||||
close(ofd);
|
||||
|
||||
exit(EXIT_FAILURE);
|
||||
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));
|
||||
}
|
||||
|
||||
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));
|
||||
|
||||
close(ifd);
|
||||
close(ofd);
|
||||
free(buffer);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user