SPL: EXYNOS: Prepare for variable size SPL support
authorRajeshwari Birje <rajeshwari.s@samsung.com>
Thu, 26 Dec 2013 04:14:27 +0000 (09:44 +0530)
committerMinkyu Kang <mk7.kang@samsung.com>
Mon, 30 Dec 2013 07:50:35 +0000 (16:50 +0900)
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>
include/configs/smdk5420.h
spl/Makefile
tools/mkexynosspl.c

index 9eab7d6b862fa85e2fe409a430207e8d1366cccb..447f8e58105f943b92af0c4b02fe49a3f1e1b355 100644 (file)
@@ -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
 
 /* 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"
 
index 2a787afa4f92e0b699feb950e7dcb8b6bb3eed7a..0caa982470bc5e6d5c28d9c08afdaec5d7c7a813 100644 (file)
@@ -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)
index ef685b77abe5b79ca16159216203d17527364c9b..32b786c724b205a5097fd2ece9291710b922926e 100644 (file)
 #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;
-
-       if (argc != 3) {
-               fprintf(stderr, "Usage: %s <infile> <outfile>\n", argv[0]);
+       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);
                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));
+       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;
+       }
 
-               close(ifd);
-               close(ofd);
+       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);
+       }
 
+       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);
        }
 
-       for (i = 0, checksum = 0; i < CHECKSUM_OFFSET; i++)
-               checksum += buffer[i];
+       /* 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 (write(ofd, buffer, BUFSIZE) != BUFSIZE) {
-               fprintf(stderr, "%s: Can't write %s: %s\n",
-                       argv[0], argv[2], strerror(errno));
+       if (var_size_flag) {
+               /* Prepare and write out the variable size SPL header. */
+               struct var_size_header vsh;
+               uint32_t spl_size;
 
-               close(ifd);
-               close(ofd);
+               memset(&vsh, 0, sizeof(vsh));
+               memcpy(&vsh.spl_checksum, &checksum, sizeof(checksum));
 
-               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;
 }