/*
   * Copyright (C) 2012 Samsung Electronics
   *
   * SPDX-License-Identifier:	GPL-2.0+
   */
  
  #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)
  /*
   * 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
  ",
  		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;
  	int i, ifd, ofd;
  	uint32_t checksum = 0;
  	off_t	len;
  	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. */
  
  	/* 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>
  ",
  			prog_name);
  		exit(EXIT_FAILURE);
  	}
  
  	/* 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
  ",
  			prog_name, argv[if_index], strerror(errno));
  		exit(EXIT_FAILURE);
  	}
  
  	ofd = open(argv[of_index], O_WRONLY | O_CREAT | O_TRUNC, FILE_PERM);
  	if (ifd < 0) {
  		fprintf(stderr, "%s: Can't open %s: %s
  ",
  			prog_name, argv[of_index], strerror(errno));
  		exit(EXIT_FAILURE);
  	}
  
  	if (fstat(ifd, &stat)) {
  		fprintf(stderr, "%s: Unable to get size of %s: %s
  ",
  			prog_name, argv[if_index], strerror(errno));
  		exit(EXIT_FAILURE);
  	}
  
  	len = stat.st_size;
  
  	if (var_size_flag) {
  		read_size = len;
  		count = len;
  	} else {
  		if (len > CHECKSUM_OFFSET) {
  			fprintf(stderr,
  				"%s: %s is too big (exceeds %d bytes)
  ",
  				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
  ",
  			prog_name, count, argv[if_index]);
  		exit(EXIT_FAILURE);
  	}
  
  	if (read(ifd, buffer, read_size) != read_size) {
  		fprintf(stderr, "%s: Can't read %s: %s
  ",
  			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);
  
  	if (var_size_flag) {
  		/* Prepare and write out the variable size SPL header. */
  		struct var_size_header vsh;
  		uint32_t spl_size;
  
  		memset(&vsh, 0, sizeof(vsh));
  		memcpy(&vsh.spl_checksum, &checksum, sizeof(checksum));
  
  		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;
  }