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!
39 #include <image-sparse.h>
43 #include <sparse_format.h>
45 #include <linux/math64.h>
47 static void default_log(const char *ignored
, char *response
) {}
49 int write_sparse_image(struct sparse_storage
*info
,
50 const char *part_name
, void *data
, char *response
)
55 uint32_t bytes_written
= 0;
58 unsigned int chunk_data_sz
;
59 uint32_t *fill_buf
= NULL
;
61 sparse_header_t
*sparse_header
;
62 chunk_header_t
*chunk_header
;
63 uint32_t total_blocks
= 0;
64 int fill_buf_num_blks
;
68 fill_buf_num_blks
= CONFIG_IMAGE_SPARSE_FILLBUF_SIZE
/ info
->blksz
;
70 /* Read and skip over sparse image header */
71 sparse_header
= (sparse_header_t
*)data
;
73 data
+= sparse_header
->file_hdr_sz
;
74 if (sparse_header
->file_hdr_sz
> sizeof(sparse_header_t
)) {
76 * Skip the remaining bytes in a header that is longer than
79 data
+= (sparse_header
->file_hdr_sz
- sizeof(sparse_header_t
));
83 info
->mssg
= default_log
;
85 debug("=== Sparse Image Header ===\n");
86 debug("magic: 0x%x\n", sparse_header
->magic
);
87 debug("major_version: 0x%x\n", sparse_header
->major_version
);
88 debug("minor_version: 0x%x\n", sparse_header
->minor_version
);
89 debug("file_hdr_sz: %d\n", sparse_header
->file_hdr_sz
);
90 debug("chunk_hdr_sz: %d\n", sparse_header
->chunk_hdr_sz
);
91 debug("blk_sz: %d\n", sparse_header
->blk_sz
);
92 debug("total_blks: %d\n", sparse_header
->total_blks
);
93 debug("total_chunks: %d\n", sparse_header
->total_chunks
);
96 * Verify that the sparse block size is a multiple of our
97 * storage backend block size
99 div_u64_rem(sparse_header
->blk_sz
, info
->blksz
, &offset
);
101 printf("%s: Sparse image block size issue [%u]\n",
102 __func__
, sparse_header
->blk_sz
);
103 info
->mssg("sparse image block size issue", response
);
107 puts("Flashing Sparse Image\n");
109 /* Start processing chunks */
111 for (chunk
= 0; chunk
< sparse_header
->total_chunks
; chunk
++) {
112 /* Read and skip over chunk header */
113 chunk_header
= (chunk_header_t
*)data
;
114 data
+= sizeof(chunk_header_t
);
116 if (chunk_header
->chunk_type
!= CHUNK_TYPE_RAW
) {
117 debug("=== Chunk Header ===\n");
118 debug("chunk_type: 0x%x\n", chunk_header
->chunk_type
);
119 debug("chunk_data_sz: 0x%x\n", chunk_header
->chunk_sz
);
120 debug("total_size: 0x%x\n", chunk_header
->total_sz
);
123 if (sparse_header
->chunk_hdr_sz
> sizeof(chunk_header_t
)) {
125 * Skip the remaining bytes in a header that is longer
128 data
+= (sparse_header
->chunk_hdr_sz
-
129 sizeof(chunk_header_t
));
132 chunk_data_sz
= sparse_header
->blk_sz
* chunk_header
->chunk_sz
;
133 blkcnt
= chunk_data_sz
/ info
->blksz
;
134 switch (chunk_header
->chunk_type
) {
136 if (chunk_header
->total_sz
!=
137 (sparse_header
->chunk_hdr_sz
+ chunk_data_sz
)) {
138 info
->mssg("Bogus chunk size for chunk type Raw",
143 if (blk
+ blkcnt
> info
->start
+ info
->size
) {
145 "%s: Request would exceed partition size!\n",
147 info
->mssg("Request would exceed partition size!",
152 blks
= info
->write(info
, blk
, blkcnt
, data
);
153 /* blks might be > blkcnt (eg. NAND bad-blocks) */
155 printf("%s: %s" LBAFU
" [" LBAFU
"]\n",
156 __func__
, "Write failed, block #",
158 info
->mssg("flash write failure", response
);
162 bytes_written
+= blkcnt
* info
->blksz
;
163 total_blocks
+= chunk_header
->chunk_sz
;
164 data
+= chunk_data_sz
;
167 case CHUNK_TYPE_FILL
:
168 if (chunk_header
->total_sz
!=
169 (sparse_header
->chunk_hdr_sz
+ sizeof(uint32_t))) {
170 info
->mssg("Bogus chunk size for chunk type FILL", response
);
174 fill_buf
= (uint32_t *)
175 memalign(ARCH_DMA_MINALIGN
,
177 info
->blksz
* fill_buf_num_blks
,
180 info
->mssg("Malloc failed for: CHUNK_TYPE_FILL",
185 fill_val
= *(uint32_t *)data
;
186 data
= (char *)data
+ sizeof(uint32_t);
189 i
< (info
->blksz
* fill_buf_num_blks
/
192 fill_buf
[i
] = fill_val
;
194 if (blk
+ blkcnt
> info
->start
+ info
->size
) {
196 "%s: Request would exceed partition size!\n",
198 info
->mssg("Request would exceed partition size!",
203 for (i
= 0; i
< blkcnt
;) {
205 if (j
> fill_buf_num_blks
)
206 j
= fill_buf_num_blks
;
207 blks
= info
->write(info
, blk
, j
, fill_buf
);
208 /* blks might be > j (eg. NAND bad-blocks) */
210 printf("%s: %s " LBAFU
" [%d]\n",
212 "Write failed, block #",
214 info
->mssg("flash write failure",
222 bytes_written
+= blkcnt
* info
->blksz
;
223 total_blocks
+= chunk_data_sz
/ sparse_header
->blk_sz
;
227 case CHUNK_TYPE_DONT_CARE
:
228 blk
+= info
->reserve(info
, blk
, blkcnt
);
229 total_blocks
+= chunk_header
->chunk_sz
;
232 case CHUNK_TYPE_CRC32
:
233 if (chunk_header
->total_sz
!=
234 sparse_header
->chunk_hdr_sz
) {
235 info
->mssg("Bogus chunk size for chunk type Dont Care",
239 total_blocks
+= chunk_header
->chunk_sz
;
240 data
+= chunk_data_sz
;
244 printf("%s: Unknown chunk type: %x\n", __func__
,
245 chunk_header
->chunk_type
);
246 info
->mssg("Unknown chunk type", response
);
251 debug("Wrote %d blocks, expected to write %d blocks\n",
252 total_blocks
, sparse_header
->total_blks
);
253 printf("........ wrote %u bytes to '%s'\n", bytes_written
, part_name
);
255 if (total_blocks
!= sparse_header
->total_blks
) {
256 info
->mssg("sparse image write failure", response
);