fastboot: sparse: make write_sparse_image useable for non-fastboot

[u-boot] / common / image-sparse.c

diff --git a/common/image-sparse.c b/common/image-sparse.c
index 9632c6f352942029232ebdfb24ac086a08e02568..9223b9a1b86ce222068e27fe2cc8a90abd83c7ce 100644 (file)
--- a/common/image-sparse.c
+++ b/common/image-sparse.c
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 2009, Google Inc.
  * All rights reserved.
@@ -42,13 +41,17 @@
 #include <malloc.h>
 #include <part.h>
 #include <sparse_format.h>
-#include <fastboot.h>
 
 #include <linux/math64.h>
 
-void write_sparse_image(
-               struct sparse_storage *info, const char *part_name,
-               void *data, unsigned sz)
+#ifndef CONFIG_FASTBOOT_FLASH_FILLBUF_SIZE
+#define CONFIG_FASTBOOT_FLASH_FILLBUF_SIZE (1024 * 512)
+#endif
+
+static void default_log(const char *ignored) {}
+
+int write_sparse_image(struct sparse_storage *info,
+                      const char *part_name, void *data)
 {
        lbaint_t blk;
        lbaint_t blkcnt;
@@ -62,7 +65,11 @@ void write_sparse_image(
        sparse_header_t *sparse_header;
        chunk_header_t *chunk_header;
        uint32_t total_blocks = 0;
+       int fill_buf_num_blks;
        int i;
+       int j;
+
+       fill_buf_num_blks = CONFIG_FASTBOOT_FLASH_FILLBUF_SIZE / info->blksz;
 
        /* Read and skip over sparse image header */
        sparse_header = (sparse_header_t *)data;
@@ -76,6 +83,9 @@ void write_sparse_image(
                data += (sparse_header->file_hdr_sz - sizeof(sparse_header_t));
        }
 
+       if (!info->mssg)
+               info->mssg = default_log;
+
        debug("=== Sparse Image Header ===\n");
        debug("magic: 0x%x\n", sparse_header->magic);
        debug("major_version: 0x%x\n", sparse_header->major_version);
@@ -94,8 +104,8 @@ void write_sparse_image(
        if (offset) {
                printf("%s: Sparse image block size issue [%u]\n",
                       __func__, sparse_header->blk_sz);
-               fastboot_fail("sparse image block size issue");
-               return;
+               info->mssg("sparse image block size issue");
+               return -1;
        }
 
        puts("Flashing Sparse Image\n");
@@ -129,18 +139,16 @@ void write_sparse_image(
                case CHUNK_TYPE_RAW:
                        if (chunk_header->total_sz !=
                            (sparse_header->chunk_hdr_sz + chunk_data_sz)) {
-                               fastboot_fail(
-                                       "Bogus chunk size for chunk type Raw");
-                               return;
+                               info->mssg("Bogus chunk size for chunk type Raw");
+                               return -1;
                        }
 
                        if (blk + blkcnt > info->start + info->size) {
                                printf(
                                    "%s: Request would exceed partition size!\n",
                                    __func__);
-                               fastboot_fail(
-                                   "Request would exceed partition size!");
-                               return;
+                               info->mssg("Request would exceed partition size!");
+                               return -1;
                        }
 
                        blks = info->write(info, blk, blkcnt, data);
@@ -149,9 +157,8 @@ void write_sparse_image(
                                printf("%s: %s" LBAFU " [" LBAFU "]\n",
                                       __func__, "Write failed, block #",
                                       blk, blks);
-                               fastboot_fail(
-                                             "flash write failure");
-                               return;
+                               info->mssg("flash write failure");
+                               return -1;
                        }
                        blk += blks;
                        bytes_written += blkcnt * info->blksz;
@@ -162,48 +169,54 @@ void write_sparse_image(
                case CHUNK_TYPE_FILL:
                        if (chunk_header->total_sz !=
                            (sparse_header->chunk_hdr_sz + sizeof(uint32_t))) {
-                               fastboot_fail(
-                                       "Bogus chunk size for chunk type FILL");
-                               return;
+                               info->mssg("Bogus chunk size for chunk type FILL");
+                               return -1;
                        }
 
                        fill_buf = (uint32_t *)
                                   memalign(ARCH_DMA_MINALIGN,
-                                           ROUNDUP(info->blksz,
-                                                   ARCH_DMA_MINALIGN));
+                                           ROUNDUP(
+                                               info->blksz * fill_buf_num_blks,
+                                               ARCH_DMA_MINALIGN));
                        if (!fill_buf) {
-                               fastboot_fail(
-                                       "Malloc failed for: CHUNK_TYPE_FILL");
-                               return;
+                               info->mssg("Malloc failed for: CHUNK_TYPE_FILL");
+                               return -1;
                        }
 
                        fill_val = *(uint32_t *)data;
                        data = (char *)data + sizeof(uint32_t);
 
-                       for (i = 0; i < (info->blksz / sizeof(fill_val)); i++)
+                       for (i = 0;
+                            i < (info->blksz * fill_buf_num_blks /
+                                 sizeof(fill_val));
+                            i++)
                                fill_buf[i] = fill_val;
 
                        if (blk + blkcnt > info->start + info->size) {
                                printf(
                                    "%s: Request would exceed partition size!\n",
                                    __func__);
-                               fastboot_fail(
-                                   "Request would exceed partition size!");
-                               return;
+                               info->mssg("Request would exceed partition size!");
+                               return -1;
                        }
 
-                       for (i = 0; i < blkcnt; i++) {
-                               blks = info->write(info, blk, 1, fill_buf);
-                               /* blks might be > 1 (eg. NAND bad-blocks) */
-                               if (blks < 1) {
-                                       printf("%s: %s, block # " LBAFU "\n",
-                                              __func__, "Write failed", blk);
-                                       fastboot_fail(
-                                                     "flash write failure");
+                       for (i = 0; i < blkcnt;) {
+                               j = blkcnt - i;
+                               if (j > fill_buf_num_blks)
+                                       j = fill_buf_num_blks;
+                               blks = info->write(info, blk, j, fill_buf);
+                               /* blks might be > j (eg. NAND bad-blocks) */
+                               if (blks < j) {
+                                       printf("%s: %s " LBAFU " [%d]\n",
+                                              __func__,
+                                              "Write failed, block #",
+                                              blk, j);
+                                       info->mssg("flash write failure");
                                        free(fill_buf);
-                                       return;
+                                       return -1;
                                }
                                blk += blks;
+                               i += j;
                        }
                        bytes_written += blkcnt * info->blksz;
                        total_blocks += chunk_data_sz / sparse_header->blk_sz;
@@ -218,9 +231,8 @@ void write_sparse_image(
                case CHUNK_TYPE_CRC32:
                        if (chunk_header->total_sz !=
                            sparse_header->chunk_hdr_sz) {
-                               fastboot_fail(
-                                       "Bogus chunk size for chunk type Dont Care");
-                               return;
+                               info->mssg("Bogus chunk size for chunk type Dont Care");
+                               return -1;
                        }
                        total_blocks += chunk_header->chunk_sz;
                        data += chunk_data_sz;
@@ -229,8 +241,8 @@ void write_sparse_image(
                default:
                        printf("%s: Unknown chunk type: %x\n", __func__,
                               chunk_header->chunk_type);
-                       fastboot_fail("Unknown chunk type");
-                       return;
+                       info->mssg("Unknown chunk type");
+                       return -1;
                }
        }
 
@@ -238,10 +250,10 @@ void write_sparse_image(
              total_blocks, sparse_header->total_blks);
        printf("........ wrote %u bytes to '%s'\n", bytes_written, part_name);
 
-       if (total_blocks != sparse_header->total_blks)
-               fastboot_fail("sparse image write failure");
-       else
-               fastboot_okay("");
+       if (total_blocks != sparse_header->total_blks) {
+               info->mssg("sparse image write failure");
+               return -1;
+       }
 
-       return;
+       return 0;
 }