]>
git.ipfire.org Git - people/ms/u-boot.git/blob - common/aboot.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!
42 #include <sparse_format.h>
44 void write_sparse_image(block_dev_desc_t
*dev_desc
,
45 disk_partition_t
*info
, const char *part_name
,
46 void *data
, unsigned sz
)
51 uint32_t bytes_written
= 0;
53 unsigned int chunk_data_sz
;
54 uint32_t *fill_buf
= NULL
;
56 sparse_header_t
*sparse_header
;
57 chunk_header_t
*chunk_header
;
58 uint32_t total_blocks
= 0;
61 /* Read and skip over sparse image header */
62 sparse_header
= (sparse_header_t
*) data
;
64 data
+= sparse_header
->file_hdr_sz
;
65 if (sparse_header
->file_hdr_sz
> sizeof(sparse_header_t
))
68 * Skip the remaining bytes in a header that is longer than
71 data
+= (sparse_header
->file_hdr_sz
- sizeof(sparse_header_t
));
74 debug("=== Sparse Image Header ===\n");
75 debug("magic: 0x%x\n", sparse_header
->magic
);
76 debug("major_version: 0x%x\n", sparse_header
->major_version
);
77 debug("minor_version: 0x%x\n", sparse_header
->minor_version
);
78 debug("file_hdr_sz: %d\n", sparse_header
->file_hdr_sz
);
79 debug("chunk_hdr_sz: %d\n", sparse_header
->chunk_hdr_sz
);
80 debug("blk_sz: %d\n", sparse_header
->blk_sz
);
81 debug("total_blks: %d\n", sparse_header
->total_blks
);
82 debug("total_chunks: %d\n", sparse_header
->total_chunks
);
84 /* verify sparse_header->blk_sz is an exact multiple of info->blksz */
85 if (sparse_header
->blk_sz
!=
86 (sparse_header
->blk_sz
& ~(info
->blksz
- 1))) {
87 printf("%s: Sparse image block size issue [%u]\n",
88 __func__
, sparse_header
->blk_sz
);
89 fastboot_fail("sparse image block size issue");
93 puts("Flashing Sparse Image\n");
95 /* Start processing chunks */
97 for (chunk
=0; chunk
<sparse_header
->total_chunks
; chunk
++)
99 /* Read and skip over chunk header */
100 chunk_header
= (chunk_header_t
*) data
;
101 data
+= sizeof(chunk_header_t
);
103 if (chunk_header
->chunk_type
!= CHUNK_TYPE_RAW
) {
104 debug("=== Chunk Header ===\n");
105 debug("chunk_type: 0x%x\n", chunk_header
->chunk_type
);
106 debug("chunk_data_sz: 0x%x\n", chunk_header
->chunk_sz
);
107 debug("total_size: 0x%x\n", chunk_header
->total_sz
);
110 if (sparse_header
->chunk_hdr_sz
> sizeof(chunk_header_t
))
113 * Skip the remaining bytes in a header that is longer
116 data
+= (sparse_header
->chunk_hdr_sz
-
117 sizeof(chunk_header_t
));
120 chunk_data_sz
= sparse_header
->blk_sz
* chunk_header
->chunk_sz
;
121 blkcnt
= chunk_data_sz
/ info
->blksz
;
122 switch (chunk_header
->chunk_type
)
125 if (chunk_header
->total_sz
!=
126 (sparse_header
->chunk_hdr_sz
+ chunk_data_sz
))
129 "Bogus chunk size for chunk type Raw");
133 if (blk
+ blkcnt
> info
->start
+ info
->size
) {
135 "%s: Request would exceed partition size!\n",
138 "Request would exceed partition size!");
142 blks
= dev_desc
->block_write(dev_desc
->dev
, blk
, blkcnt
,
144 if (blks
!= blkcnt
) {
145 printf("%s: Write failed " LBAFU
"\n",
147 fastboot_fail("flash write failure");
151 bytes_written
+= blkcnt
* info
->blksz
;
152 total_blocks
+= chunk_header
->chunk_sz
;
153 data
+= chunk_data_sz
;
156 case CHUNK_TYPE_FILL
:
157 if (chunk_header
->total_sz
!=
158 (sparse_header
->chunk_hdr_sz
+ sizeof(uint32_t)))
161 "Bogus chunk size for chunk type FILL");
165 fill_buf
= (uint32_t *)
166 memalign(ARCH_DMA_MINALIGN
,
172 "Malloc failed for: CHUNK_TYPE_FILL");
176 fill_val
= *(uint32_t *)data
;
177 data
= (char *) data
+ sizeof(uint32_t);
179 for (i
= 0; i
< (info
->blksz
/ sizeof(fill_val
)); i
++)
180 fill_buf
[i
] = fill_val
;
182 if (blk
+ blkcnt
> info
->start
+ info
->size
) {
184 "%s: Request would exceed partition size!\n",
187 "Request would exceed partition size!");
191 for (i
= 0; i
< blkcnt
; i
++) {
192 blks
= dev_desc
->block_write(dev_desc
->dev
,
196 "%s: Write failed, block # " LBAFU
"\n",
198 fastboot_fail("flash write failure");
204 bytes_written
+= blkcnt
* info
->blksz
;
205 total_blocks
+= chunk_data_sz
/ sparse_header
->blk_sz
;
210 case CHUNK_TYPE_DONT_CARE
:
212 total_blocks
+= chunk_header
->chunk_sz
;
215 case CHUNK_TYPE_CRC32
:
216 if (chunk_header
->total_sz
!=
217 sparse_header
->chunk_hdr_sz
)
220 "Bogus chunk size for chunk type Dont Care");
223 total_blocks
+= chunk_header
->chunk_sz
;
224 data
+= chunk_data_sz
;
228 printf("%s: Unknown chunk type: %x\n", __func__
,
229 chunk_header
->chunk_type
);
230 fastboot_fail("Unknown chunk type");
235 debug("Wrote %d blocks, expected to write %d blocks\n",
236 total_blocks
, sparse_header
->total_blks
);
237 printf("........ wrote %u bytes to '%s'\n", bytes_written
, part_name
);
239 if (total_blocks
!= sparse_header
->total_blks
)
240 fastboot_fail("sparse image write failure");