]>
git.ipfire.org Git - people/ms/u-boot.git/blob - common/image-sparse.c
893c68b35f7bd4fd0ba63c5572540308b68f8309
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!
41 #include <image-sparse.h>
44 #include <sparse_format.h>
46 #include <linux/math64.h>
48 typedef struct sparse_buffer
{
55 static unsigned int sparse_get_chunk_data_size(sparse_header_t
*sparse
,
56 chunk_header_t
*chunk
)
58 return chunk
->total_sz
- sparse
->chunk_hdr_sz
;
61 static unsigned int sparse_block_size_to_storage(unsigned int size
,
62 sparse_storage_t
*storage
,
63 sparse_header_t
*sparse
)
65 return (unsigned int)lldiv((uint64_t)size
* sparse
->blk_sz
,
69 static bool sparse_chunk_has_buffer(chunk_header_t
*chunk
)
71 switch (chunk
->chunk_type
) {
81 static sparse_header_t
*sparse_parse_header(void **data
)
83 /* Read and skip over sparse image header */
84 sparse_header_t
*sparse_header
= (sparse_header_t
*) *data
;
86 *data
+= sparse_header
->file_hdr_sz
;
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
);
101 static int sparse_parse_fill_chunk(sparse_header_t
*sparse
,
102 chunk_header_t
*chunk
)
104 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
106 if (chunk_data_sz
!= sizeof(uint32_t))
112 static int sparse_parse_raw_chunk(sparse_header_t
*sparse
,
113 chunk_header_t
*chunk
)
115 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
117 /* Check if the data size is a multiple of the main block size */
118 if (chunk_data_sz
% sparse
->blk_sz
)
121 /* Check that the chunk size is consistent */
122 if ((chunk_data_sz
/ sparse
->blk_sz
) != chunk
->chunk_sz
)
128 static chunk_header_t
*sparse_parse_chunk(sparse_header_t
*sparse
,
131 chunk_header_t
*chunk
= (chunk_header_t
*) *image
;
134 debug("=== Chunk Header ===\n");
135 debug("chunk_type: 0x%x\n", chunk
->chunk_type
);
136 debug("chunk_data_sz: 0x%x\n", chunk
->chunk_sz
);
137 debug("total_size: 0x%x\n", chunk
->total_sz
);
139 switch (chunk
->chunk_type
) {
141 ret
= sparse_parse_raw_chunk(sparse
, chunk
);
146 case CHUNK_TYPE_FILL
:
147 ret
= sparse_parse_fill_chunk(sparse
, chunk
);
152 case CHUNK_TYPE_DONT_CARE
:
153 case CHUNK_TYPE_CRC32
:
154 debug("Ignoring chunk\n");
158 printf("%s: Unknown chunk type: %x\n", __func__
,
163 *image
+= sparse
->chunk_hdr_sz
;
168 static int sparse_get_fill_buffer(sparse_header_t
*sparse
,
169 chunk_header_t
*chunk
,
170 sparse_buffer_t
*buffer
,
176 buffer
->type
= CHUNK_TYPE_FILL
;
179 * We create a buffer of one block, and ask it to be
180 * repeated as many times as needed.
182 buffer
->length
= blk_sz
;
183 buffer
->repeat
= (chunk
->chunk_sz
* sparse
->blk_sz
) / blk_sz
;
185 buffer
->data
= memalign(ARCH_DMA_MINALIGN
,
191 for (i
= 0; i
< (buffer
->length
/ sizeof(uint32_t)); i
++)
192 ((uint32_t *)buffer
->data
)[i
] = *(uint32_t *)(data
);
197 static int sparse_get_raw_buffer(sparse_header_t
*sparse
,
198 chunk_header_t
*chunk
,
199 sparse_buffer_t
*buffer
,
203 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
205 buffer
->type
= CHUNK_TYPE_RAW
;
206 buffer
->length
= chunk_data_sz
;
213 static sparse_buffer_t
*sparse_get_data_buffer(sparse_header_t
*sparse
,
214 chunk_header_t
*chunk
,
218 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
219 sparse_buffer_t
*buffer
;
223 *image
+= chunk_data_sz
;
225 if (!sparse_chunk_has_buffer(chunk
))
228 buffer
= calloc(sizeof(sparse_buffer_t
), 1);
232 switch (chunk
->chunk_type
) {
234 ret
= sparse_get_raw_buffer(sparse
, chunk
, buffer
, blk_sz
,
240 case CHUNK_TYPE_FILL
:
241 ret
= sparse_get_fill_buffer(sparse
, chunk
, buffer
, blk_sz
,
251 debug("=== Buffer ===\n");
252 debug("length: 0x%x\n", buffer
->length
);
253 debug("repeat: 0x%x\n", buffer
->repeat
);
254 debug("type: 0x%x\n", buffer
->type
);
255 debug("data: 0x%p\n", buffer
->data
);
260 static void sparse_put_data_buffer(sparse_buffer_t
*buffer
)
262 if (buffer
->type
== CHUNK_TYPE_FILL
)
268 int store_sparse_image(sparse_storage_t
*storage
,
269 void *storage_priv
, void *data
)
271 unsigned int chunk
, offset
;
272 sparse_header_t
*sparse_header
;
273 chunk_header_t
*chunk_header
;
274 sparse_buffer_t
*buffer
;
276 uint32_t total_blocks
= 0;
279 debug("=== Storage ===\n");
280 debug("name: %s\n", storage
->name
);
281 debug("block_size: 0x%x\n", storage
->block_sz
);
282 debug("start: 0x%x\n", storage
->start
);
283 debug("size: 0x%x\n", storage
->size
);
284 debug("write: 0x%p\n", storage
->write
);
285 debug("priv: 0x%p\n", storage_priv
);
287 sparse_header
= sparse_parse_header(&data
);
288 if (!sparse_header
) {
289 printf("sparse header issue\n");
294 * Verify that the sparse block size is a multiple of our
295 * storage backend block size
297 div_u64_rem(sparse_header
->blk_sz
, storage
->block_sz
, &offset
);
299 printf("%s: Sparse image block size issue [%u]\n",
300 __func__
, sparse_header
->blk_sz
);
304 puts("Flashing Sparse Image\n");
306 /* Start processing chunks */
307 start
= storage
->start
;
308 for (chunk
= 0; chunk
< sparse_header
->total_chunks
; chunk
++) {
311 chunk_header
= sparse_parse_chunk(sparse_header
, &data
);
313 printf("Unknown chunk type");
318 * If we have a DONT_CARE type, just skip the blocks
319 * and go on parsing the rest of the chunks
321 if (chunk_header
->chunk_type
== CHUNK_TYPE_DONT_CARE
) {
322 blkcnt
= sparse_block_size_to_storage(chunk_header
->chunk_sz
,
325 #ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
326 total_blocks
+= blkcnt
;
331 /* Retrieve the buffer we're going to write */
332 buffer
= sparse_get_data_buffer(sparse_header
, chunk_header
,
333 storage
->block_sz
, &data
);
337 blkcnt
= (buffer
->length
/ storage
->block_sz
) * buffer
->repeat
;
339 if ((start
+ total_blocks
+ blkcnt
) >
340 (storage
->start
+ storage
->size
)) {
341 printf("%s: Request would exceed partition size!\n",
346 for (i
= 0; i
< buffer
->repeat
; i
++) {
347 unsigned long buffer_blk_cnt
;
350 buffer_blk_cnt
= buffer
->length
/ storage
->block_sz
;
352 ret
= storage
->write(storage
, storage_priv
,
353 start
+ total_blocks
,
357 printf("%s: Write %d failed %d\n",
365 sparse_put_data_buffer(buffer
);
368 debug("Wrote %d blocks, expected to write %d blocks\n",
370 sparse_block_size_to_storage(sparse_header
->total_blks
,
371 storage
, sparse_header
));
372 printf("........ wrote %d blocks to '%s'\n", total_blocks
,
376 sparse_block_size_to_storage(sparse_header
->total_blks
,
377 storage
, sparse_header
)) {
378 printf("sparse image write failure\n");