]>
git.ipfire.org Git - people/ms/u-boot.git/blob - common/image-sparse.c
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 uint32_t last_offset
;
57 static unsigned int sparse_get_chunk_data_size(sparse_header_t
*sparse
,
58 chunk_header_t
*chunk
)
60 return chunk
->total_sz
- sparse
->chunk_hdr_sz
;
63 static unsigned int sparse_block_size_to_storage(unsigned int size
,
64 sparse_storage_t
*storage
,
65 sparse_header_t
*sparse
)
67 return (unsigned int)lldiv((uint64_t)size
* sparse
->blk_sz
,
71 static bool sparse_chunk_has_buffer(chunk_header_t
*chunk
)
73 switch (chunk
->chunk_type
) {
83 static sparse_header_t
*sparse_parse_header(void **data
)
85 /* Read and skip over sparse image header */
86 sparse_header_t
*sparse_header
= (sparse_header_t
*) *data
;
88 *data
+= sparse_header
->file_hdr_sz
;
90 debug("=== Sparse Image Header ===\n");
91 debug("magic: 0x%x\n", sparse_header
->magic
);
92 debug("major_version: 0x%x\n", sparse_header
->major_version
);
93 debug("minor_version: 0x%x\n", sparse_header
->minor_version
);
94 debug("file_hdr_sz: %d\n", sparse_header
->file_hdr_sz
);
95 debug("chunk_hdr_sz: %d\n", sparse_header
->chunk_hdr_sz
);
96 debug("blk_sz: %d\n", sparse_header
->blk_sz
);
97 debug("total_blks: %d\n", sparse_header
->total_blks
);
98 debug("total_chunks: %d\n", sparse_header
->total_chunks
);
100 return sparse_header
;
103 static int sparse_parse_fill_chunk(sparse_header_t
*sparse
,
104 chunk_header_t
*chunk
)
106 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
108 if (chunk_data_sz
!= sizeof(uint32_t))
114 static int sparse_parse_raw_chunk(sparse_header_t
*sparse
,
115 chunk_header_t
*chunk
)
117 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
119 /* Check if the data size is a multiple of the main block size */
120 if (chunk_data_sz
% sparse
->blk_sz
)
123 /* Check that the chunk size is consistent */
124 if ((chunk_data_sz
/ sparse
->blk_sz
) != chunk
->chunk_sz
)
130 static chunk_header_t
*sparse_parse_chunk(sparse_header_t
*sparse
,
133 chunk_header_t
*chunk
= (chunk_header_t
*) *image
;
136 debug("=== Chunk Header ===\n");
137 debug("chunk_type: 0x%x\n", chunk
->chunk_type
);
138 debug("chunk_data_sz: 0x%x\n", chunk
->chunk_sz
);
139 debug("total_size: 0x%x\n", chunk
->total_sz
);
141 switch (chunk
->chunk_type
) {
143 ret
= sparse_parse_raw_chunk(sparse
, chunk
);
148 case CHUNK_TYPE_FILL
:
149 ret
= sparse_parse_fill_chunk(sparse
, chunk
);
154 case CHUNK_TYPE_DONT_CARE
:
155 case CHUNK_TYPE_CRC32
:
156 debug("Ignoring chunk\n");
160 printf("%s: Unknown chunk type: %x\n", __func__
,
165 *image
+= sparse
->chunk_hdr_sz
;
170 static int sparse_get_fill_buffer(sparse_header_t
*sparse
,
171 chunk_header_t
*chunk
,
172 sparse_buffer_t
*buffer
,
178 buffer
->type
= CHUNK_TYPE_FILL
;
181 * We create a buffer of one block, and ask it to be
182 * repeated as many times as needed.
184 buffer
->length
= blk_sz
;
185 buffer
->repeat
= (chunk
->chunk_sz
* sparse
->blk_sz
) / blk_sz
;
187 buffer
->data
= memalign(ARCH_DMA_MINALIGN
,
193 for (i
= 0; i
< (buffer
->length
/ sizeof(uint32_t)); i
++)
194 ((uint32_t *)buffer
->data
)[i
] = *(uint32_t *)(data
);
199 static int sparse_get_raw_buffer(sparse_header_t
*sparse
,
200 chunk_header_t
*chunk
,
201 sparse_buffer_t
*buffer
,
205 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
207 buffer
->type
= CHUNK_TYPE_RAW
;
208 buffer
->length
= chunk_data_sz
;
215 static sparse_buffer_t
*sparse_get_data_buffer(sparse_header_t
*sparse
,
216 chunk_header_t
*chunk
,
220 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
221 sparse_buffer_t
*buffer
;
225 *image
+= chunk_data_sz
;
227 if (!sparse_chunk_has_buffer(chunk
))
230 buffer
= calloc(sizeof(sparse_buffer_t
), 1);
234 switch (chunk
->chunk_type
) {
236 ret
= sparse_get_raw_buffer(sparse
, chunk
, buffer
, blk_sz
,
242 case CHUNK_TYPE_FILL
:
243 ret
= sparse_get_fill_buffer(sparse
, chunk
, buffer
, blk_sz
,
253 debug("=== Buffer ===\n");
254 debug("length: 0x%x\n", buffer
->length
);
255 debug("repeat: 0x%x\n", buffer
->repeat
);
256 debug("type: 0x%x\n", buffer
->type
);
257 debug("data: 0x%p\n", buffer
->data
);
262 static void sparse_put_data_buffer(sparse_buffer_t
*buffer
)
264 if (buffer
->type
== CHUNK_TYPE_FILL
)
270 int store_sparse_image(sparse_storage_t
*storage
, void *storage_priv
,
271 unsigned int session_id
, void *data
)
273 unsigned int chunk
, offset
;
274 sparse_header_t
*sparse_header
;
275 chunk_header_t
*chunk_header
;
276 sparse_buffer_t
*buffer
;
278 uint32_t total_blocks
= 0;
279 uint32_t skipped
= 0;
282 debug("=== Storage ===\n");
283 debug("name: %s\n", storage
->name
);
284 debug("block_size: 0x%x\n", storage
->block_sz
);
285 debug("start: 0x%x\n", storage
->start
);
286 debug("size: 0x%x\n", storage
->size
);
287 debug("write: 0x%p\n", storage
->write
);
288 debug("priv: 0x%p\n", storage_priv
);
290 sparse_header
= sparse_parse_header(&data
);
291 if (!sparse_header
) {
292 printf("sparse header issue\n");
297 * Verify that the sparse block size is a multiple of our
298 * storage backend block size
300 div_u64_rem(sparse_header
->blk_sz
, storage
->block_sz
, &offset
);
302 printf("%s: Sparse image block size issue [%u]\n",
303 __func__
, sparse_header
->blk_sz
);
308 * If it's a new flashing session, start at the beginning of
309 * the partition. If not, then simply resume where we were.
314 start
= storage
->start
;
316 printf("Flashing sparse image on partition %s at offset 0x%x (ID: %d)\n",
317 storage
->name
, start
* storage
->block_sz
, session_id
);
319 /* Start processing chunks */
320 for (chunk
= 0; chunk
< sparse_header
->total_chunks
; chunk
++) {
323 chunk_header
= sparse_parse_chunk(sparse_header
, &data
);
325 printf("Unknown chunk type");
330 * If we have a DONT_CARE type, just skip the blocks
331 * and go on parsing the rest of the chunks
333 if (chunk_header
->chunk_type
== CHUNK_TYPE_DONT_CARE
) {
334 blkcnt
= sparse_block_size_to_storage(chunk_header
->chunk_sz
,
337 #ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
338 total_blocks
+= blkcnt
;
344 /* Retrieve the buffer we're going to write */
345 buffer
= sparse_get_data_buffer(sparse_header
, chunk_header
,
346 storage
->block_sz
, &data
);
350 blkcnt
= (buffer
->length
/ storage
->block_sz
) * buffer
->repeat
;
352 if ((start
+ total_blocks
+ blkcnt
) >
353 (storage
->start
+ storage
->size
)) {
354 printf("%s: Request would exceed partition size!\n",
359 for (i
= 0; i
< buffer
->repeat
; i
++) {
360 unsigned long buffer_blk_cnt
;
363 buffer_blk_cnt
= buffer
->length
/ storage
->block_sz
;
365 ret
= storage
->write(storage
, storage_priv
,
366 start
+ total_blocks
,
370 printf("%s: Write %d failed %d\n",
378 sparse_put_data_buffer(buffer
);
381 debug("Wrote %d blocks, skipped %d, expected to write %d blocks\n",
382 total_blocks
, skipped
,
383 sparse_block_size_to_storage(sparse_header
->total_blks
,
384 storage
, sparse_header
));
385 printf("........ wrote %d blocks to '%s'\n", total_blocks
,
389 sparse_block_size_to_storage(sparse_header
->total_blks
,
390 storage
, sparse_header
)) {
391 printf("sparse image write failure\n");
395 last_offset
= start
+ total_blocks
;