rockchip: mkimage: use imagename to select spl hdr & spl size

Our chips may have different spl size and spl header, so
use imagename(passed by "mkimage -n") to select them now.

Signed-off-by: Jeffy Chen <jeffy.chen@rock-chips.com>
Acked-by: Simon Glass <sjg@chromium.org>

diff --git a/tools/rkcommon.c b/tools/rkcommon.c
index 9e2173fa58042efb6f647e897911e625860f7f5b..72621fd095c69b69e7db9878b17b5bac30e8636b 100644 (file)
--- a/tools/rkcommon.c
+++ b/tools/rkcommon.c
@@ -40,16 +40,84 @@ struct header0_info {
        uint8_t reserved2[2];
 };
 
+/**
+ * struct spl_info - spl info for each chip
+ *
+ * @imagename:         Image name(passed by "mkimage -n")
+ * @spl_hdr:           Boot ROM requires a 4-bytes spl header
+ * @spl_size:          Spl size(include extra 4-bytes spl header)
+ */
+struct spl_info {
+       const char *imagename;
+       const char *spl_hdr;
+       const uint32_t spl_size;
+};
+
+static struct spl_info spl_infos[] = {
+       { "rk3036", "RK30", 0x1000 },
+       { "rk3288", "RK32", 0x8000 },
+};
+
 static unsigned char rc4_key[16] = {
        124, 78, 3, 4, 85, 5, 9, 7,
        45, 44, 123, 56, 23, 13, 23, 17
 };
 
-int rkcommon_set_header(void *buf, uint file_size)
+static struct spl_info *rkcommon_get_spl_info(char *imagename)
+{
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(spl_infos); i++)
+               if (!strncmp(imagename, spl_infos[i].imagename, 6))
+                       return spl_infos + i;
+
+       return NULL;
+}
+
+int rkcommon_check_params(struct image_tool_params *params)
+{
+       int i;
+
+       if (rkcommon_get_spl_info(params->imagename) != NULL)
+               return 0;
+
+       fprintf(stderr, "ERROR: imagename (%s) is not supported!\n",
+               strlen(params->imagename) > 0 ? params->imagename : "NULL");
+
+       fprintf(stderr, "Available imagename:");
+       for (i = 0; i < ARRAY_SIZE(spl_infos); i++)
+               fprintf(stderr, "\t%s", spl_infos[i].imagename);
+       fprintf(stderr, "\n");
+
+       return -1;
+}
+
+const char *rkcommon_get_spl_hdr(struct image_tool_params *params)
+{
+       struct spl_info *info = rkcommon_get_spl_info(params->imagename);
+
+       /*
+        * info would not be NULL, because of we checked params before.
+        */
+       return info->spl_hdr;
+}
+
+int rkcommon_get_spl_size(struct image_tool_params *params)
+{
+       struct spl_info *info = rkcommon_get_spl_info(params->imagename);
+
+       /*
+        * info would not be NULL, because of we checked params before.
+        */
+       return info->spl_size;
+}
+
+int rkcommon_set_header(void *buf, uint file_size,
+                       struct image_tool_params *params)
 {
        struct header0_info *hdr;
 
-       if (file_size > RK_MAX_CODE1_SIZE)
+       if (file_size > rkcommon_get_spl_size(params))
                return -ENOSPC;
 
        memset(buf,  '\0', RK_INIT_OFFSET * RK_BLK_SIZE);

diff --git a/tools/rkcommon.h b/tools/rkcommon.h
index 222156e7e8467a12ed3a460e10ef1d037aac930c..c69540f5f38a35cab4bd9566af073716175e2139 100644 (file)
--- a/tools/rkcommon.h
+++ b/tools/rkcommon.h
@@ -12,9 +12,37 @@ enum {
        RK_BLK_SIZE             = 512,
        RK_INIT_OFFSET          = 4,
        RK_MAX_BOOT_SIZE        = 512 << 10,
-       RK_MAX_CODE1_SIZE       = 32 << 10,
+       RK_SPL_HDR_START        = RK_INIT_OFFSET * RK_BLK_SIZE,
+       RK_SPL_HDR_SIZE         = 4,
+       RK_SPL_START            = RK_SPL_HDR_START + RK_SPL_HDR_SIZE,
+       RK_IMAGE_HEADER_LEN     = RK_SPL_START,
 };
 
+/**
+ * rkcommon_check_params() - check params
+ *
+ * @return 0 if OK, -1 if ERROR.
+ */
+int rkcommon_check_params(struct image_tool_params *params);
+
+/**
+ * rkcommon_get_spl_hdr() - get 4-bytes spl hdr for a Rockchip boot image
+ *
+ * Rockchip's bootrom requires the spl loader to start with a 4-bytes
+ * header. The content of this header depends on the chip type.
+ */
+const char *rkcommon_get_spl_hdr(struct image_tool_params *params);
+
+/**
+ * rkcommon_get_spl_size() - get spl size for a Rockchip boot image
+ *
+ * Different chip may have different sram size. And if we want to jump
+ * back to the bootrom after spl, we may need to reserve some sram space
+ * for the bootrom.
+ * The spl loader size should be sram size minus reserved size(if needed)
+ */
+int rkcommon_get_spl_size(struct image_tool_params *params);
+
 /**
  * rkcommon_set_header() - set up the header for a Rockchip boot image
  *
@@ -24,6 +52,7 @@ enum {
  * @file_size: Size of the file we want the boot ROM to load, in bytes
  * @return 0 if OK, -ENOSPC if too large
  */
-int rkcommon_set_header(void *buf, uint file_size);
+int rkcommon_set_header(void *buf, uint file_size,
+                       struct image_tool_params *params);
 
 #endif

diff --git a/tools/rkimage.c b/tools/rkimage.c
index 7b292f4235d1f43216c933cc5260b615bb73fbb0..f9fdcfa712f00496a88404a0181f783b158859fa 100644 (file)
--- a/tools/rkimage.c
+++ b/tools/rkimage.c
@@ -9,6 +9,7 @@
 
 #include "imagetool.h"
 #include <image.h>
+#include "rkcommon.h"
 
 static uint32_t header;
 
@@ -30,7 +31,8 @@ static void rkimage_print_header(const void *buf)
 static void rkimage_set_header(void *buf, struct stat *sbuf, int ifd,
                               struct image_tool_params *params)
 {
-       memcpy(buf, "RK32", 4);
+       memcpy(buf + RK_SPL_HDR_START, rkcommon_get_spl_hdr(params),
+              RK_SPL_HDR_SIZE);
 }
 
 static int rkimage_extract_subimage(void *buf, struct image_tool_params *params)

diff --git a/tools/rksd.c b/tools/rksd.c
index 39f5c75e69ffd0a12dbdec503512ecd5dd46f5e0..a2baa74d3121168503f65ea56ee3b3a9a0b16f68 100644 (file)
--- a/tools/rksd.c
+++ b/tools/rksd.c
@@ -13,18 +13,7 @@
 #include "mkimage.h"
 #include "rkcommon.h"
 
-enum {
-       RKSD_SPL_HDR_START      = RK_INIT_OFFSET * RK_BLK_SIZE,
-       RKSD_SPL_START          = RKSD_SPL_HDR_START + 4,
-       RKSD_HEADER_LEN         = RKSD_SPL_START,
-};
-
-static char dummy_hdr[RKSD_HEADER_LEN];
-
-static int rksd_check_params(struct image_tool_params *params)
-{
-       return 0;
-}
+static char dummy_hdr[RK_IMAGE_HEADER_LEN];
 
 static int rksd_verify_header(unsigned char *buf,  int size,
                                 struct image_tool_params *params)
@@ -42,15 +31,16 @@ static void rksd_set_header(void *buf,  struct stat *sbuf,  int ifd,
        unsigned int size;
        int ret;
 
-       size = params->file_size - RKSD_SPL_HDR_START;
-       ret = rkcommon_set_header(buf, size);
+       size = params->file_size - RK_SPL_HDR_START;
+       ret = rkcommon_set_header(buf, size, params);
        if (ret) {
                /* TODO(sjg@chromium.org): This method should return an error */
                printf("Warning: SPL image is too large (size %#x) and will not boot\n",
                       size);
        }
 
-       memcpy(buf + RKSD_SPL_HDR_START, "RK32", 4);
+       memcpy(buf + RK_SPL_HDR_START, rkcommon_get_spl_hdr(params),
+              RK_SPL_HDR_SIZE);
 }
 
 static int rksd_extract_subimage(void *buf,  struct image_tool_params *params)
@@ -72,7 +62,7 @@ static int rksd_vrec_header(struct image_tool_params *params,
 {
        int pad_size;
 
-       pad_size = RKSD_SPL_HDR_START + RK_MAX_CODE1_SIZE;
+       pad_size = RK_SPL_HDR_START + rkcommon_get_spl_size(params);
        debug("pad_size %x\n", pad_size);
 
        return pad_size - params->file_size;
@@ -84,9 +74,9 @@ static int rksd_vrec_header(struct image_tool_params *params,
 U_BOOT_IMAGE_TYPE(
        rksd,
        "Rockchip SD Boot Image support",
-       RKSD_HEADER_LEN,
+       RK_IMAGE_HEADER_LEN,
        dummy_hdr,
-       rksd_check_params,
+       rkcommon_check_params,
        rksd_verify_header,
        rksd_print_header,
        rksd_set_header,

diff --git a/tools/rkspi.c b/tools/rkspi.c
index eb8119bf53fb8ce3f04baead9e5e190594eb6663..800e235168ff5d041469c4c57bc0b5a7c44bc781 100644 (file)
--- a/tools/rkspi.c
+++ b/tools/rkspi.c
@@ -14,18 +14,10 @@
 #include "rkcommon.h"
 
 enum {
-       RKSPI_SPL_HDR_START     = RK_INIT_OFFSET * RK_BLK_SIZE,
-       RKSPI_SPL_START         = RKSPI_SPL_HDR_START + 4,
-       RKSPI_HEADER_LEN        = RKSPI_SPL_START,
        RKSPI_SECT_LEN          = RK_BLK_SIZE * 4,
 };
 
-static char dummy_hdr[RKSPI_HEADER_LEN];
-
-static int rkspi_check_params(struct image_tool_params *params)
-{
-       return 0;
-}
+static char dummy_hdr[RK_IMAGE_HEADER_LEN];
 
 static int rkspi_verify_header(unsigned char *buf, int size,
                               struct image_tool_params *params)
@@ -45,7 +37,7 @@ static void rkspi_set_header(void *buf, struct stat *sbuf, int ifd,
        int ret;
 
        size = params->orig_file_size;
-       ret = rkcommon_set_header(buf, size);
+       ret = rkcommon_set_header(buf, size, params);
        debug("size %x\n", size);
        if (ret) {
                /* TODO(sjg@chromium.org): This method should return an error */
@@ -53,7 +45,8 @@ static void rkspi_set_header(void *buf, struct stat *sbuf, int ifd,
                       size);
        }
 
-       memcpy(buf + RKSPI_SPL_HDR_START, "RK32", 4);
+       memcpy(buf + RK_SPL_HDR_START, rkcommon_get_spl_hdr(params),
+              RK_SPL_HDR_SIZE);
 
        /*
         * Spread the image out so we only use the first 2KB of each 4KB
@@ -89,12 +82,12 @@ static int rkspi_vrec_header(struct image_tool_params *params,
 {
        int pad_size;
 
-       pad_size = (RK_MAX_CODE1_SIZE + 0x7ff) / 0x800 * 0x800;
+       pad_size = (rkcommon_get_spl_size(params) + 0x7ff) / 0x800 * 0x800;
        params->orig_file_size = pad_size;
 
        /* We will double the image size due to the SPI format */
        pad_size *= 2;
-       pad_size += RKSPI_SPL_HDR_START;
+       pad_size += RK_SPL_HDR_START;
        debug("pad_size %x\n", pad_size);
 
        return pad_size - params->file_size;
@@ -106,9 +99,9 @@ static int rkspi_vrec_header(struct image_tool_params *params,
 U_BOOT_IMAGE_TYPE(
        rkspi,
        "Rockchip SPI Boot Image support",
-       RKSPI_HEADER_LEN,
+       RK_IMAGE_HEADER_LEN,
        dummy_hdr,
-       rkspi_check_params,
+       rkcommon_check_params,
        rkspi_verify_header,
        rkspi_print_header,
        rkspi_set_header,