bootm: Export bootm_decomp_image()

[karo-tx-uboot.git] / common / bootm.c

diff --git a/common/bootm.c b/common/bootm.c
index 6b3ea8c61b69c180e146cf5607a7780e2726f996..10c15ef91cf8ce07e8c85d4e6e7542e385c8a76a 100644 (file)
--- a/common/bootm.c
+++ b/common/bootm.c
@@ -264,25 +264,36 @@ static int bootm_find_other(cmd_tbl_t *cmdtp, int flag, int argc,
 
        return 0;
 }
-#endif /* USE_HOSTCC */
+#endif /* USE_HOSTC */
 
-/**
- * decomp_image() - decompress the operating system
- *
- * @comp:      Compression algorithm that is used (IH_COMP_...)
- * @load:      Destination load address in U-Boot memory
- * @image_start Image start address (where we are decompressing from)
- * @type:      OS type (IH_OS_...)
- * @load_bug:  Place to decompress to
- * @image_buf: Address to decompress from
- * @return 0 if OK, -ve on error (BOOTM_ERR_...)
- */
-static int decomp_image(int comp, ulong load, ulong image_start, int type,
-                       void *load_buf, void *image_buf, ulong image_len,
-                       ulong *load_end)
+#if defined(CONFIG_GZIP) || defined(CONFIG_GZIP) || defined(CONFIG_BZIP2) || \
+       defined(CONFIG_LZMA) || defined(CONFIG_LZO)
+static void print_decomp_msg(const char *type_name)
+{
+       printf("   Uncompressing %s ... ", type_name);
+}
+
+static int handle_decomp_error(const char *algo, size_t size, size_t unc_len,
+                              int ret)
+{
+       if (size >= unc_len)
+               puts("Image too large: increase CONFIG_SYS_BOOTM_LEN\n");
+       else
+               printf("%s: uncompress or overwrite error %d\n", algo, ret);
+       puts("Must RESET board to recover\n");
+#ifndef USE_HOSTCC
+       bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
+#endif
+
+       return BOOTM_ERR_RESET;
+}
+#endif
+
+int bootm_decomp_image(int comp, ulong load, ulong image_start, int type,
+                      void *load_buf, void *image_buf, ulong image_len,
+                      uint unc_len, ulong *load_end)
 {
        const char *type_name = genimg_get_type_name(type);
-       __attribute__((unused)) uint unc_len = CONFIG_SYS_BOOTM_LEN;
 
        *load_end = load;
        switch (comp) {
@@ -296,19 +307,25 @@ static int decomp_image(int comp, ulong load, ulong image_start, int type,
                *load_end = load + image_len;
                break;
 #ifdef CONFIG_GZIP
-       case IH_COMP_GZIP:
-               printf("   Uncompressing %s ... ", type_name);
-               if (gunzip(load_buf, unc_len, image_buf, &image_len) != 0) {
-                       puts("GUNZIP: uncompress, out-of-mem or overwrite error - must RESET board to recover\n");
-                       return BOOTM_ERR_RESET;
+       case IH_COMP_GZIP: {
+               int ret;
+
+               print_decomp_msg(type_name);
+               ret = gunzip(load_buf, unc_len, image_buf, &image_len);
+               if (ret != 0) {
+                       return handle_decomp_error("GUNZIP", image_len,
+                                                  unc_len, ret);
                }
 
                *load_end = load + image_len;
                break;
+       }
 #endif /* CONFIG_GZIP */
 #ifdef CONFIG_BZIP2
-       case IH_COMP_BZIP2:
-               printf("   Uncompressing %s ... ", type_name);
+       case IH_COMP_BZIP2: {
+               size_t size = unc_len;
+
+               print_decomp_msg(type_name);
                /*
                 * If we've got less than 4 MB of malloc() space,
                 * use slower decompression algorithm which requires
@@ -318,30 +335,27 @@ static int decomp_image(int comp, ulong load, ulong image_start, int type,
                        image_buf, image_len,
                        CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
                if (i != BZ_OK) {
-                       printf("BUNZIP2: uncompress or overwrite error %d - must RESET board to recover\n",
-                              i);
-                       return BOOTM_ERR_RESET;
+                       return handle_decomp_error("BUNZIP2", size, unc_len,
+                                                  i);
                }
 
                *load_end = load + unc_len;
                break;
+       }
 #endif /* CONFIG_BZIP2 */
 #ifdef CONFIG_LZMA
        case IH_COMP_LZMA: {
                SizeT lzma_len = unc_len;
                int ret;
 
-               printf("   Uncompressing %s ... ", type_name);
-
+               print_decomp_msg(type_name);
                ret = lzmaBuffToBuffDecompress(load_buf, &lzma_len,
                                               image_buf, image_len);
-               unc_len = lzma_len;
                if (ret != SZ_OK) {
-                       printf("LZMA: uncompress or overwrite error %d - must RESET board to recover\n",
-                              ret);
-                       bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
-                       return BOOTM_ERR_RESET;
+                       return handle_decomp_error("LZMA", lzma_len, unc_len,
+                                                  ret);
                }
+               unc_len = lzma_len;
                *load_end = load + unc_len;
                break;
        }
@@ -351,14 +365,11 @@ static int decomp_image(int comp, ulong load, ulong image_start, int type,
                size_t size = unc_len;
                int ret;
 
-               printf("   Uncompressing %s ... ", type_name);
+               print_decomp_msg(type_name);
 
                ret = lzop_decompress(image_buf, image_len, load_buf, &size);
-               if (ret != LZO_E_OK) {
-                       printf("LZO: uncompress or overwrite error %d - must RESET board to recover\n",
-                              ret);
-                       return BOOTM_ERR_RESET;
-               }
+               if (ret != LZO_E_OK)
+                       return handle_decomp_error("LZO", size, unc_len, ret);
 
                *load_end = load + size;
                break;
@@ -390,8 +401,9 @@ static int bootm_load_os(bootm_headers_t *images, unsigned long *load_end,
 
        load_buf = map_sysmem(load, 0);
        image_buf = map_sysmem(os.image_start, image_len);
-       err = decomp_image(os.comp, load, os.image_start, os.type, load_buf,
-                          image_buf, image_len, load_end);
+       err = bootm_decomp_image(os.comp, load, os.image_start, os.type,
+                                load_buf, image_buf, image_len,
+                                CONFIG_SYS_BOOTM_LEN, load_end);
        if (err) {
                bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
                return err;
@@ -882,9 +894,11 @@ static int bootm_host_load_image(const void *fit, int req_image_type)
 
        /* Allow the image to expand by a factor of 4, should be safe */
        load_buf = malloc((1 << 20) + len * 4);
-       ret = decomp_image(imape_comp, 0, data, image_type, load_buf,
-                          (void *)data, len, &load_end);
+       ret = bootm_decomp_image(imape_comp, 0, data, image_type, load_buf,
+                                (void *)data, len, CONFIG_SYS_BOOTM_LEN,
+                                &load_end);
        free(load_buf);
+
        if (ret && ret != BOOTM_ERR_UNIMPLEMENTED)
                return ret;