]>
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 size
* sparse
->blk_sz
/ storage
->block_sz
;
70 static bool sparse_chunk_has_buffer(chunk_header_t
*chunk
)
72 switch (chunk
->chunk_type
) {
82 static sparse_header_t
*sparse_parse_header(void **data
)
84 /* Read and skip over sparse image header */
85 sparse_header_t
*sparse_header
= (sparse_header_t
*) *data
;
87 *data
+= sparse_header
->file_hdr_sz
;
89 debug("=== Sparse Image Header ===\n");
90 debug("magic: 0x%x\n", sparse_header
->magic
);
91 debug("major_version: 0x%x\n", sparse_header
->major_version
);
92 debug("minor_version: 0x%x\n", sparse_header
->minor_version
);
93 debug("file_hdr_sz: %d\n", sparse_header
->file_hdr_sz
);
94 debug("chunk_hdr_sz: %d\n", sparse_header
->chunk_hdr_sz
);
95 debug("blk_sz: %d\n", sparse_header
->blk_sz
);
96 debug("total_blks: %d\n", sparse_header
->total_blks
);
97 debug("total_chunks: %d\n", sparse_header
->total_chunks
);
102 static int sparse_parse_fill_chunk(sparse_header_t
*sparse
,
103 chunk_header_t
*chunk
)
105 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
107 if (chunk_data_sz
!= sizeof(uint32_t))
113 static int sparse_parse_raw_chunk(sparse_header_t
*sparse
,
114 chunk_header_t
*chunk
)
116 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
118 /* Check if the data size is a multiple of the main block size */
119 if (chunk_data_sz
% sparse
->blk_sz
)
122 /* Check that the chunk size is consistent */
123 if ((chunk_data_sz
/ sparse
->blk_sz
) != chunk
->chunk_sz
)
129 static chunk_header_t
*sparse_parse_chunk(sparse_header_t
*sparse
,
132 chunk_header_t
*chunk
= (chunk_header_t
*) *image
;
135 debug("=== Chunk Header ===\n");
136 debug("chunk_type: 0x%x\n", chunk
->chunk_type
);
137 debug("chunk_data_sz: 0x%x\n", chunk
->chunk_sz
);
138 debug("total_size: 0x%x\n", chunk
->total_sz
);
140 switch (chunk
->chunk_type
) {
142 ret
= sparse_parse_raw_chunk(sparse
, chunk
);
147 case CHUNK_TYPE_FILL
:
148 ret
= sparse_parse_fill_chunk(sparse
, chunk
);
153 case CHUNK_TYPE_DONT_CARE
:
154 case CHUNK_TYPE_CRC32
:
155 debug("Ignoring chunk\n");
159 printf("%s: Unknown chunk type: %x\n", __func__
,
164 *image
+= sparse
->chunk_hdr_sz
;
169 static int sparse_get_fill_buffer(sparse_header_t
*sparse
,
170 chunk_header_t
*chunk
,
171 sparse_buffer_t
*buffer
,
177 buffer
->type
= CHUNK_TYPE_FILL
;
180 * We create a buffer of one block, and ask it to be
181 * repeated as many times as needed.
183 buffer
->length
= blk_sz
;
184 buffer
->repeat
= (chunk
->chunk_sz
* sparse
->blk_sz
) / blk_sz
;
186 buffer
->data
= memalign(ARCH_DMA_MINALIGN
,
192 for (i
= 0; i
< (buffer
->length
/ sizeof(uint32_t)); i
++)
193 ((uint32_t *)buffer
->data
)[i
] = *(uint32_t *)(data
);
198 static int sparse_get_raw_buffer(sparse_header_t
*sparse
,
199 chunk_header_t
*chunk
,
200 sparse_buffer_t
*buffer
,
204 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
206 buffer
->type
= CHUNK_TYPE_RAW
;
207 buffer
->length
= chunk_data_sz
;
214 static sparse_buffer_t
*sparse_get_data_buffer(sparse_header_t
*sparse
,
215 chunk_header_t
*chunk
,
219 unsigned int chunk_data_sz
= sparse_get_chunk_data_size(sparse
, chunk
);
220 sparse_buffer_t
*buffer
;
224 *image
+= chunk_data_sz
;
226 if (!sparse_chunk_has_buffer(chunk
))
229 buffer
= calloc(sizeof(sparse_buffer_t
), 1);
233 switch (chunk
->chunk_type
) {
235 ret
= sparse_get_raw_buffer(sparse
, chunk
, buffer
, blk_sz
,
241 case CHUNK_TYPE_FILL
:
242 ret
= sparse_get_fill_buffer(sparse
, chunk
, buffer
, blk_sz
,
252 debug("=== Buffer ===\n");
253 debug("length: 0x%x\n", buffer
->length
);
254 debug("repeat: 0x%x\n", buffer
->repeat
);
255 debug("type: 0x%x\n", buffer
->type
);
256 debug("data: 0x%p\n", buffer
->data
);
261 static void sparse_put_data_buffer(sparse_buffer_t
*buffer
)
263 if (buffer
->type
== CHUNK_TYPE_FILL
)
269 int store_sparse_image(sparse_storage_t
*storage
, void *storage_priv
,
270 unsigned int session_id
, void *data
)
272 unsigned int chunk
, offset
;
273 sparse_header_t
*sparse_header
;
274 chunk_header_t
*chunk_header
;
275 sparse_buffer_t
*buffer
;
277 uint32_t total_blocks
= 0;
278 uint32_t skipped
= 0;
281 debug("=== Storage ===\n");
282 debug("name: %s\n", storage
->name
);
283 debug("block_size: 0x%x\n", storage
->block_sz
);
284 debug("start: 0x%x\n", storage
->start
);
285 debug("size: 0x%x\n", storage
->size
);
286 debug("write: 0x%p\n", storage
->write
);
287 debug("priv: 0x%p\n", storage_priv
);
289 sparse_header
= sparse_parse_header(&data
);
290 if (!sparse_header
) {
291 printf("sparse header issue\n");
296 * Verify that the sparse block size is a multiple of our
297 * storage backend block size
299 div_u64_rem(sparse_header
->blk_sz
, storage
->block_sz
, &offset
);
301 printf("%s: Sparse image block size issue [%u]\n",
302 __func__
, sparse_header
->blk_sz
);
307 * If it's a new flashing session, start at the beginning of
308 * the partition. If not, then simply resume where we were.
313 start
= storage
->start
;
315 printf("Flashing sparse image on partition %s at offset 0x%x (ID: %d)\n",
316 storage
->name
, start
* storage
->block_sz
, session_id
);
318 /* Start processing chunks */
319 for (chunk
= 0; chunk
< sparse_header
->total_chunks
; chunk
++) {
322 chunk_header
= sparse_parse_chunk(sparse_header
, &data
);
324 printf("Unknown chunk type");
329 * If we have a DONT_CARE type, just skip the blocks
330 * and go on parsing the rest of the chunks
332 if (chunk_header
->chunk_type
== CHUNK_TYPE_DONT_CARE
) {
333 skipped
+= sparse_block_size_to_storage(chunk_header
->chunk_sz
,
339 /* Retrieve the buffer we're going to write */
340 buffer
= sparse_get_data_buffer(sparse_header
, chunk_header
,
341 storage
->block_sz
, &data
);
345 blkcnt
= (buffer
->length
/ storage
->block_sz
) * buffer
->repeat
;
347 if ((start
+ total_blocks
+ blkcnt
) >
348 (storage
->start
+ storage
->size
)) {
349 printf("%s: Request would exceed partition size!\n",
354 for (i
= 0; i
< buffer
->repeat
; i
++) {
355 unsigned long buffer_blk_cnt
;
358 buffer_blk_cnt
= buffer
->length
/ storage
->block_sz
;
360 ret
= storage
->write(storage
, storage_priv
,
361 start
+ total_blocks
,
365 printf("%s: Write %d failed %d\n",
373 sparse_put_data_buffer(buffer
);
376 debug("Wrote %d blocks, skipped %d, expected to write %d blocks\n",
377 total_blocks
, skipped
,
378 sparse_block_size_to_storage(sparse_header
->total_blks
,
379 storage
, sparse_header
));
380 printf("........ wrote %d blocks to '%s'\n", total_blocks
,
383 if ((total_blocks
+ skipped
) !=
384 sparse_block_size_to_storage(sparse_header
->total_blks
,
385 storage
, sparse_header
)) {
386 printf("sparse image write failure\n");
390 last_offset
= start
+ total_blocks
;