tools: mkimage: add support for gpimage format

This patch add support for gpimage format as a preparatory
patch for porting u-boot for keystone2 devices and is
based on omapimage format. It re-uses gph header to store the
size and loadaddr as done in omapimage.c

Signed-off-by: Vitaly Andrianov <vitalya@ti.com>
Signed-off-by: Murali Karicheri <m-karicheri2@ti.com>
Acked-by: Tom Rini <trini@ti.com>

diff --git a/common/image.c b/common/image.c
index 9c6bec5b769ceb1834ffa978827c89609ad8402f..fcc5a9c3e12ae581dea63888ece615f4a3df27c2 100644 (file)
--- a/common/image.c
+++ b/common/image.c
@@ -125,6 +125,7 @@ static const table_entry_t uimage_type[] = {
        {       IH_TYPE_FILESYSTEM, "filesystem", "Filesystem Image",   },
        {       IH_TYPE_FIRMWARE,   "firmware",   "Firmware",           },
        {       IH_TYPE_FLATDT,     "flat_dt",    "Flat Device Tree",   },
+       {       IH_TYPE_GPIMAGE,    "gpimage",    "TI Keystone SPL Image",},
        {       IH_TYPE_KERNEL,     "kernel",     "Kernel Image",       },
        {       IH_TYPE_KERNEL_NOLOAD, "kernel_noload",  "Kernel Image (no loading done)", },
        {       IH_TYPE_KWBIMAGE,   "kwbimage",   "Kirkwood Boot Image",},

diff --git a/include/image.h b/include/image.h
index 6afd57bafddec7ac067a948897018d3bc334915c..8095bc8914356524cd085e99077d0768e36a9721 100644 (file)
--- a/include/image.h
+++ b/include/image.h
@@ -215,6 +215,7 @@ struct lmb;
 #define IH_TYPE_KERNEL_NOLOAD  14      /* OS Kernel Image, can run from any load address */
 #define IH_TYPE_PBLIMAGE       15      /* Freescale PBL Boot Image     */
 #define IH_TYPE_MXSIMAGE       16      /* Freescale MXSBoot Image      */
+#define IH_TYPE_GPIMAGE                17      /* TI Keystone GPHeader Image   */
 
 /*
  * Compression Types

diff --git a/tools/Makefile b/tools/Makefile
index 097cc1df17838af2f0904f1f6a361efb94d328d2..911ad435900d2c24f5ac7a93f2cfa32b221df369 100644 (file)
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -73,6 +73,8 @@ dumpimage-mkimage-objs := aisimage.o \
                        crc32.o \
                        default_image.o \
                        fit_image.o \
+                       gpimage.o \
+                       gpimage-common.o \
                        image-fit.o \
                        image-host.o \
                        image.o \

diff --git a/tools/gpheader.h b/tools/gpheader.h
new file mode 100644 (file)
index 0000000..63a28a2
--- /dev/null
+++ b/tools/gpheader.h
@@ -0,0 +1,40 @@
+/*
+ * (C) Copyright 2014
+ * Texas Instruments Incorporated
+ * Refactored common functions in to gpimage-common.c. Include this common
+ * header file
+ *
+ * (C) Copyright 2010
+ * Linaro LTD, www.linaro.org
+ * Author: John Rigby <john.rigby@linaro.org>
+ * Based on TI's signGP.c
+ *
+ * (C) Copyright 2009
+ * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
+ *
+ * (C) Copyright 2008
+ * Marvell Semiconductor <www.marvell.com>
+ * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#ifndef _GPIMAGE_H_
+#define _GPIMAGE_H_
+
+/* common headers for gpimage and omapimage formats */
+struct gp_header {
+       uint32_t size;
+       uint32_t load_addr;
+};
+#define GPIMAGE_HDR_SIZE (sizeof(struct gp_header))
+
+/* common functions across gpimage and omapimage handlers */
+int valid_gph_size(uint32_t size);
+int valid_gph_load_addr(uint32_t load_addr);
+int gph_verify_header(struct gp_header *gph, int be);
+void gph_print_header(const struct gp_header *gph, int be);
+void gph_set_header(struct gp_header *gph, uint32_t size, uint32_t load_addr,
+                       int be);
+int gpimage_check_params(struct image_tool_params *params);
+#endif

diff --git a/tools/gpimage-common.c b/tools/gpimage-common.c
new file mode 100644 (file)
index 0000000..b343a3a
--- /dev/null
+++ b/tools/gpimage-common.c
@@ -0,0 +1,80 @@
+/*
+ * (C) Copyright 2014
+ * Texas Instruments Incorporated
+ * Refactored common functions in to gpimage-common.c.
+ *
+ * (C) Copyright 2010
+ * Linaro LTD, www.linaro.org
+ * Author: John Rigby <john.rigby@linaro.org>
+ * Based on TI's signGP.c
+ *
+ * (C) Copyright 2009
+ * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
+ *
+ * (C) Copyright 2008
+ * Marvell Semiconductor <www.marvell.com>
+ * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include "imagetool.h"
+#include <compiler.h>
+#include <image.h>
+#include "gpheader.h"
+
+/* Helper to convert size and load_addr to big endian */
+void to_be32(uint32_t *gph_size, uint32_t *gph_load_addr)
+{
+       *gph_size = cpu_to_be32(*gph_size);
+       *gph_load_addr = cpu_to_be32(*gph_load_addr);
+}
+
+int gph_verify_header(struct gp_header *gph, int be)
+{
+       uint32_t gph_size = gph->size, gph_load_addr = gph->load_addr;
+
+       if (be)
+               to_be32(&gph_size, &gph_load_addr);
+
+       if (!gph_size || !gph_load_addr)
+               return -1;
+
+       return 0;
+}
+
+void gph_print_header(const struct gp_header *gph, int be)
+{
+       uint32_t gph_size = gph->size, gph_load_addr = gph->load_addr;
+
+       if (be)
+               to_be32(&gph_size, &gph_load_addr);
+
+       if (!gph_size) {
+               fprintf(stderr, "Error: invalid image size %x\n", gph_size);
+               exit(EXIT_FAILURE);
+       }
+
+       if (!gph_load_addr) {
+               fprintf(stderr, "Error: invalid image load address %x\n",
+                       gph_load_addr);
+               exit(EXIT_FAILURE);
+       }
+       printf("GP Header: Size %x LoadAddr %x\n", gph_size, gph_load_addr);
+}
+
+void gph_set_header(struct gp_header *gph, uint32_t size, uint32_t load_addr,
+       int be)
+{
+       gph->size = size;
+       gph->load_addr = load_addr;
+       if (be)
+               to_be32(&gph->size, &gph->load_addr);
+}
+
+int gpimage_check_params(struct image_tool_params *params)
+{
+       return  (params->dflag && (params->fflag || params->lflag)) ||
+               (params->fflag && (params->dflag || params->lflag)) ||
+               (params->lflag && (params->dflag || params->fflag));
+}

diff --git a/tools/gpimage.c b/tools/gpimage.c
new file mode 100644 (file)
index 0000000..1cabb5b
--- /dev/null
+++ b/tools/gpimage.c
@@ -0,0 +1,77 @@
+/*
+ * (C) Copyright 2014
+ * Texas Instruments Incorporated
+ * Add gpimage format for keystone devices to format spl image. This is
+ * Based on omapimage.c
+ *
+ * (C) Copyright 2010
+ * Linaro LTD, www.linaro.org
+ * Author: John Rigby <john.rigby@linaro.org>
+ * Based on TI's signGP.c
+ *
+ * (C) Copyright 2009
+ * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
+ *
+ * (C) Copyright 2008
+ * Marvell Semiconductor <www.marvell.com>
+ * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include "imagetool.h"
+#include <compiler.h>
+#include <image.h>
+#include "gpheader.h"
+
+static uint8_t gpimage_header[GPIMAGE_HDR_SIZE];
+
+/* to be in keystone gpimage */
+static int gpimage_check_image_types(uint8_t type)
+{
+       if (type == IH_TYPE_GPIMAGE)
+               return EXIT_SUCCESS;
+       return EXIT_FAILURE;
+}
+
+static int gpimage_verify_header(unsigned char *ptr, int image_size,
+                       struct image_tool_params *params)
+{
+       struct gp_header *gph = (struct gp_header *)ptr;
+
+       return gph_verify_header(gph, 1);
+}
+
+static void gpimage_print_header(const void *ptr)
+{
+       const struct gp_header *gph = (struct gp_header *)ptr;
+
+       gph_print_header(gph, 1);
+}
+
+static void gpimage_set_header(void *ptr, struct stat *sbuf, int ifd,
+                               struct image_tool_params *params)
+{
+       struct gp_header *gph = (struct gp_header *)ptr;
+
+       gph_set_header(gph, sbuf->st_size - GPIMAGE_HDR_SIZE, params->addr, 1);
+}
+
+/*
+ * gpimage parameters
+ */
+static struct image_type_params gpimage_params = {
+       .name           = "TI KeyStone GP Image support",
+       .header_size    = GPIMAGE_HDR_SIZE,
+       .hdr            = (void *)&gpimage_header,
+       .check_image_type = gpimage_check_image_types,
+       .verify_header  = gpimage_verify_header,
+       .print_header   = gpimage_print_header,
+       .set_header     = gpimage_set_header,
+       .check_params   = gpimage_check_params,
+};
+
+void init_gpimage_type(void)
+{
+       register_image_type(&gpimage_params);
+}

diff --git a/tools/imagetool.c b/tools/imagetool.c
index 29d2189097898e18428eb2ba800c824afe01318f..da72115e53230a53444078df089186d932bec54b 100644 (file)
--- a/tools/imagetool.c
+++ b/tools/imagetool.c
@@ -45,6 +45,8 @@ void register_image_tool(imagetool_register_t image_register)
        init_ubl_image_type();
        /* Init Davinci AIS support */
        init_ais_image_type();
+       /* Init TI Keystone boot image generation/list support */
+       init_gpimage_type();
 }
 
 /*

diff --git a/tools/imagetool.h b/tools/imagetool.h
index c2c9aea60eb15dbf75a33d438bd0c973daf082be..a3e9d302eb3f9de7324a5055521b9008b24bcfa5 100644 (file)
--- a/tools/imagetool.h
+++ b/tools/imagetool.h
@@ -167,6 +167,7 @@ void init_mxs_image_type(void);
 void init_fit_image_type(void);
 void init_ubl_image_type(void);
 void init_omap_image_type(void);
+void init_gpimage_type(void);
 
 void pbl_load_uboot(int fd, struct image_tool_params *mparams);
 

diff --git a/tools/omapimage.c b/tools/omapimage.c
index d59bc4d40de1f26d9c6a0691b757ec1a689ef29b..1e0c16479681aec2d8621eabd953ff9a8cdb203c 100644 (file)
--- a/tools/omapimage.c
+++ b/tools/omapimage.c
@@ -15,57 +15,24 @@
  */
 
 #include "imagetool.h"
+#include <compiler.h>
 #include <image.h>
+#include "gpheader.h"
 #include "omapimage.h"
 
 /* Header size is CH header rounded up to 512 bytes plus GP header */
 #define OMAP_CH_HDR_SIZE 512
-#define OMAP_GP_HDR_SIZE (sizeof(struct gp_header))
-#define OMAP_FILE_HDR_SIZE (OMAP_CH_HDR_SIZE+OMAP_GP_HDR_SIZE)
+#define OMAP_FILE_HDR_SIZE (OMAP_CH_HDR_SIZE + GPIMAGE_HDR_SIZE)
 
 static int do_swap32 = 0;
 
-static uint32_t omapimage_swap32(uint32_t data)
-{
-       uint32_t result = 0;
-       result  = (data & 0xFF000000) >> 24;
-       result |= (data & 0x00FF0000) >> 8;
-       result |= (data & 0x0000FF00) << 8;
-       result |= (data & 0x000000FF) << 24;
-       return result;
-}
-
 static uint8_t omapimage_header[OMAP_FILE_HDR_SIZE];
 
 static int omapimage_check_image_types(uint8_t type)
 {
        if (type == IH_TYPE_OMAPIMAGE)
                return EXIT_SUCCESS;
-       else {
-               return EXIT_FAILURE;
-       }
-}
-
-/*
- * Only the simplest image type is currently supported:
- * TOC pointing to CHSETTINGS
- * TOC terminator
- * CHSETTINGS
- *
- * padding to OMAP_CH_HDR_SIZE bytes
- *
- * gp header
- *   size
- *   load_addr
- */
-static int valid_gph_size(uint32_t size)
-{
-       return size;
-}
-
-static int valid_gph_load_addr(uint32_t load_addr)
-{
-       return load_addr;
+       return EXIT_FAILURE;
 }
 
 static int omapimage_verify_header(unsigned char *ptr, int image_size,
@@ -73,13 +40,13 @@ static int omapimage_verify_header(unsigned char *ptr, int image_size,
 {
        struct ch_toc *toc = (struct ch_toc *)ptr;
        struct gp_header *gph = (struct gp_header *)(ptr+OMAP_CH_HDR_SIZE);
-       uint32_t offset, size, gph_size, gph_load_addr;
+       uint32_t offset, size;
 
        while (toc->section_offset != 0xffffffff
                        && toc->section_size != 0xffffffff) {
                if (do_swap32) {
-                       offset = omapimage_swap32(toc->section_offset);
-                       size = omapimage_swap32(toc->section_size);
+                       offset = cpu_to_be32(toc->section_offset);
+                       size = cpu_to_be32(toc->section_size);
                } else {
                        offset = toc->section_offset;
                        size = toc->section_size;
@@ -92,20 +59,7 @@ static int omapimage_verify_header(unsigned char *ptr, int image_size,
                toc++;
        }
 
-       if (do_swap32) {
-               gph_size = omapimage_swap32(gph->size);
-               gph_load_addr = omapimage_swap32(gph->load_addr);
-       } else {
-               gph_size = gph->size;
-               gph_load_addr = gph->load_addr;
-       }
-
-       if (!valid_gph_size(gph_size))
-               return -1;
-       if (!valid_gph_load_addr(gph_load_addr))
-               return -1;
-
-       return 0;
+       return gph_verify_header(gph, do_swap32);
 }
 
 static void omapimage_print_section(struct ch_settings *chs)
@@ -135,13 +89,13 @@ static void omapimage_print_header(const void *ptr)
        const struct ch_toc *toc = (struct ch_toc *)ptr;
        const struct gp_header *gph =
                        (struct gp_header *)(ptr+OMAP_CH_HDR_SIZE);
-       uint32_t offset, size, gph_size, gph_load_addr;
+       uint32_t offset, size;
 
        while (toc->section_offset != 0xffffffff
                        && toc->section_size != 0xffffffff) {
                if (do_swap32) {
-                       offset = omapimage_swap32(toc->section_offset);
-                       size = omapimage_swap32(toc->section_size);
+                       offset = cpu_to_be32(toc->section_offset);
+                       size = cpu_to_be32(toc->section_size);
                } else {
                        offset = toc->section_offset;
                        size = toc->section_size;
@@ -160,26 +114,7 @@ static void omapimage_print_header(const void *ptr)
                toc++;
        }
 
-       if (do_swap32) {
-               gph_size = omapimage_swap32(gph->size);
-               gph_load_addr = omapimage_swap32(gph->load_addr);
-       } else {
-               gph_size = gph->size;
-               gph_load_addr = gph->load_addr;
-       }
-
-       if (!valid_gph_size(gph_size)) {
-               fprintf(stderr, "Error: invalid image size %x\n", gph_size);
-               exit(EXIT_FAILURE);
-       }
-
-       if (!valid_gph_load_addr(gph_load_addr)) {
-               fprintf(stderr, "Error: invalid image load address %x\n",
-                               gph_load_addr);
-               exit(EXIT_FAILURE);
-       }
-
-       printf("GP Header: Size %x LoadAddr %x\n", gph_size, gph_load_addr);
+       gph_print_header(gph, do_swap32);
 }
 
 static int toc_offset(void *hdr, void *member)
@@ -208,8 +143,8 @@ static void omapimage_set_header(void *ptr, struct stat *sbuf, int ifd,
        toc++;
        memset(toc, 0xff, sizeof(*toc));
 
-       gph->size = sbuf->st_size - OMAP_FILE_HDR_SIZE;
-       gph->load_addr = params->addr;
+       gph_set_header(gph, sbuf->st_size - OMAP_FILE_HDR_SIZE,
+                      params->addr, 0);
 
        if (strncmp(params->imagename, "byteswap", 8) == 0) {
                do_swap32 = 1;
@@ -217,20 +152,13 @@ static void omapimage_set_header(void *ptr, struct stat *sbuf, int ifd,
                uint32_t *data = (uint32_t *)ptr;
 
                while (swapped <= (sbuf->st_size / sizeof(uint32_t))) {
-                       *data = omapimage_swap32(*data);
+                       *data = cpu_to_be32(*data);
                        swapped++;
                        data++;
                }
        }
 }
 
-int omapimage_check_params(struct image_tool_params *params)
-{
-       return  (params->dflag && (params->fflag || params->lflag)) ||
-               (params->fflag && (params->dflag || params->lflag)) ||
-               (params->lflag && (params->dflag || params->fflag));
-}
-
 /*
  * omapimage parameters
  */
@@ -242,7 +170,7 @@ static struct image_type_params omapimage_params = {
        .verify_header  = omapimage_verify_header,
        .print_header   = omapimage_print_header,
        .set_header     = omapimage_set_header,
-       .check_params   = omapimage_check_params,
+       .check_params   = gpimage_check_params,
 };
 
 void init_omap_image_type(void)

diff --git a/tools/omapimage.h b/tools/omapimage.h
index 45d14eaf9cc4731e8cd86c454dfb83c8a9ff7674..8744ae7a2de7969227edec35aa6652006c03b07d 100644 (file)
--- a/tools/omapimage.h
+++ b/tools/omapimage.h
@@ -25,10 +25,5 @@ struct ch_settings {
        uint32_t flags;
 };
 
-struct gp_header {
-       uint32_t size;
-       uint32_t load_addr;
-};
-
 #define KEY_CHSETTINGS 0xC0C0C0C1
 #endif /* _OMAPIMAGE_H_ */