2 * Copyright (c) 2009, Google Inc.
5 * Copyright (c) 2009-2014, The Linux Foundation. All rights reserved.
6 * Portions Copyright 2014 Broadcom Corporation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * * Neither the name of The Linux Foundation nor
16 * the names of its contributors may be used to endorse or promote
17 * products derived from this software without specific prior written
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 * NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
30 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 * Although it is very similar, this license text is not identical
34 * to the "BSD-3-Clause", therefore, DO NOT MODIFY THIS LICENSE TEXT!
40 #include <image-sparse.h>
45 #include <sparse_format.h>
46 #include <asm/cache.h>
48 #include <linux/math64.h>
50 static void default_log(const char *ignored
, char *response
) {}
52 int write_sparse_image(struct sparse_storage
*info
,
53 const char *part_name
, void *data
, char *response
)
58 uint32_t bytes_written
= 0;
61 unsigned int chunk_data_sz
;
62 uint32_t *fill_buf
= NULL
;
64 sparse_header_t
*sparse_header
;
65 chunk_header_t
*chunk_header
;
66 uint32_t total_blocks
= 0;
67 int fill_buf_num_blks
;
71 fill_buf_num_blks
= CONFIG_IMAGE_SPARSE_FILLBUF_SIZE
/ info
->blksz
;
73 /* Read and skip over sparse image header */
74 sparse_header
= (sparse_header_t
*)data
;
76 data
+= sparse_header
->file_hdr_sz
;
77 if (sparse_header
->file_hdr_sz
> sizeof(sparse_header_t
)) {
79 * Skip the remaining bytes in a header that is longer than
82 data
+= (sparse_header
->file_hdr_sz
- sizeof(sparse_header_t
));
86 info
->mssg
= default_log
;
88 debug("=== Sparse Image Header ===\n");
89 debug("magic: 0x%x\n", sparse_header
->magic
);
90 debug("major_version: 0x%x\n", sparse_header
->major_version
);
91 debug("minor_version: 0x%x\n", sparse_header
->minor_version
);
92 debug("file_hdr_sz: %d\n", sparse_header
->file_hdr_sz
);
93 debug("chunk_hdr_sz: %d\n", sparse_header
->chunk_hdr_sz
);
94 debug("blk_sz: %d\n", sparse_header
->blk_sz
);
95 debug("total_blks: %d\n", sparse_header
->total_blks
);
96 debug("total_chunks: %d\n", sparse_header
->total_chunks
);
99 * Verify that the sparse block size is a multiple of our
100 * storage backend block size
102 div_u64_rem(sparse_header
->blk_sz
, info
->blksz
, &offset
);
104 printf("%s: Sparse image block size issue [%u]\n",
105 __func__
, sparse_header
->blk_sz
);
106 info
->mssg("sparse image block size issue", response
);
110 puts("Flashing Sparse Image\n");
112 /* Start processing chunks */
114 for (chunk
= 0; chunk
< sparse_header
->total_chunks
; chunk
++) {
115 /* Read and skip over chunk header */
116 chunk_header
= (chunk_header_t
*)data
;
117 data
+= sizeof(chunk_header_t
);
119 if (chunk_header
->chunk_type
!= CHUNK_TYPE_RAW
) {
120 debug("=== Chunk Header ===\n");
121 debug("chunk_type: 0x%x\n", chunk_header
->chunk_type
);
122 debug("chunk_data_sz: 0x%x\n", chunk_header
->chunk_sz
);
123 debug("total_size: 0x%x\n", chunk_header
->total_sz
);
126 if (sparse_header
->chunk_hdr_sz
> sizeof(chunk_header_t
)) {
128 * Skip the remaining bytes in a header that is longer
131 data
+= (sparse_header
->chunk_hdr_sz
-
132 sizeof(chunk_header_t
));
135 chunk_data_sz
= sparse_header
->blk_sz
* chunk_header
->chunk_sz
;
136 blkcnt
= chunk_data_sz
/ info
->blksz
;
137 switch (chunk_header
->chunk_type
) {
139 if (chunk_header
->total_sz
!=
140 (sparse_header
->chunk_hdr_sz
+ chunk_data_sz
)) {
141 info
->mssg("Bogus chunk size for chunk type Raw",
146 if (blk
+ blkcnt
> info
->start
+ info
->size
) {
148 "%s: Request would exceed partition size!\n",
150 info
->mssg("Request would exceed partition size!",
155 blks
= info
->write(info
, blk
, blkcnt
, data
);
156 /* blks might be > blkcnt (eg. NAND bad-blocks) */
158 printf("%s: %s" LBAFU
" [" LBAFU
"]\n",
159 __func__
, "Write failed, block #",
161 info
->mssg("flash write failure", response
);
165 bytes_written
+= blkcnt
* info
->blksz
;
166 total_blocks
+= chunk_header
->chunk_sz
;
167 data
+= chunk_data_sz
;
170 case CHUNK_TYPE_FILL
:
171 if (chunk_header
->total_sz
!=
172 (sparse_header
->chunk_hdr_sz
+ sizeof(uint32_t))) {
173 info
->mssg("Bogus chunk size for chunk type FILL", response
);
177 fill_buf
= (uint32_t *)
178 memalign(ARCH_DMA_MINALIGN
,
180 info
->blksz
* fill_buf_num_blks
,
183 info
->mssg("Malloc failed for: CHUNK_TYPE_FILL",
188 fill_val
= *(uint32_t *)data
;
189 data
= (char *)data
+ sizeof(uint32_t);
192 i
< (info
->blksz
* fill_buf_num_blks
/
195 fill_buf
[i
] = fill_val
;
197 if (blk
+ blkcnt
> info
->start
+ info
->size
) {
199 "%s: Request would exceed partition size!\n",
201 info
->mssg("Request would exceed partition size!",
206 for (i
= 0; i
< blkcnt
;) {
208 if (j
> fill_buf_num_blks
)
209 j
= fill_buf_num_blks
;
210 blks
= info
->write(info
, blk
, j
, fill_buf
);
211 /* blks might be > j (eg. NAND bad-blocks) */
213 printf("%s: %s " LBAFU
" [%d]\n",
215 "Write failed, block #",
217 info
->mssg("flash write failure",
225 bytes_written
+= blkcnt
* info
->blksz
;
226 total_blocks
+= chunk_data_sz
/ sparse_header
->blk_sz
;
230 case CHUNK_TYPE_DONT_CARE
:
231 blk
+= info
->reserve(info
, blk
, blkcnt
);
232 total_blocks
+= chunk_header
->chunk_sz
;
235 case CHUNK_TYPE_CRC32
:
236 if (chunk_header
->total_sz
!=
237 sparse_header
->chunk_hdr_sz
) {
238 info
->mssg("Bogus chunk size for chunk type Dont Care",
242 total_blocks
+= chunk_header
->chunk_sz
;
243 data
+= chunk_data_sz
;
247 printf("%s: Unknown chunk type: %x\n", __func__
,
248 chunk_header
->chunk_type
);
249 info
->mssg("Unknown chunk type", response
);
254 debug("Wrote %d blocks, expected to write %d blocks\n",
255 total_blocks
, sparse_header
->total_blks
);
256 printf("........ wrote %u bytes to '%s'\n", bytes_written
, part_name
);
258 if (total_blocks
!= sparse_header
->total_blks
) {
259 info
->mssg("sparse image write failure", response
);