1 /* 2 * Copyright (c) 2009, Google Inc. 3 * All rights reserved. 4 * 5 * Copyright (c) 2009-2014, The Linux Foundation. All rights reserved. 6 * Portions Copyright 2014 Broadcom Corporation. 7 * 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 18 * permission. 19 * 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. 31 * 32 * NOTE: 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! 35 */ 36 37 #include <config.h> 38 #include <common.h> 39 #include <div64.h> 40 #include <errno.h> 41 #include <image-sparse.h> 42 #include <malloc.h> 43 #include <part.h> 44 #include <sparse_format.h> 45 46 #include <linux/math64.h> 47 48 typedef struct sparse_buffer { 49 void *data; 50 u32 length; 51 u32 repeat; 52 u16 type; 53 } sparse_buffer_t; 54 55 static uint32_t last_offset; 56 57 static unsigned int sparse_get_chunk_data_size(sparse_header_t *sparse, 58 chunk_header_t *chunk) 59 { 60 return chunk->total_sz - sparse->chunk_hdr_sz; 61 } 62 63 static unsigned int sparse_block_size_to_storage(unsigned int size, 64 sparse_storage_t *storage, 65 sparse_header_t *sparse) 66 { 67 return (unsigned int)lldiv((uint64_t)size * sparse->blk_sz, 68 storage->block_sz); 69 } 70 71 static bool sparse_chunk_has_buffer(chunk_header_t *chunk) 72 { 73 switch (chunk->chunk_type) { 74 case CHUNK_TYPE_RAW: 75 case CHUNK_TYPE_FILL: 76 return true; 77 78 default: 79 return false; 80 } 81 } 82 83 static sparse_header_t *sparse_parse_header(void **data) 84 { 85 /* Read and skip over sparse image header */ 86 sparse_header_t *sparse_header = (sparse_header_t *) *data; 87 88 *data += sparse_header->file_hdr_sz; 89 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); 99 100 return sparse_header; 101 } 102 103 static int sparse_parse_fill_chunk(sparse_header_t *sparse, 104 chunk_header_t *chunk) 105 { 106 unsigned int chunk_data_sz = sparse_get_chunk_data_size(sparse, chunk); 107 108 if (chunk_data_sz != sizeof(uint32_t)) 109 return -EINVAL; 110 111 return 0; 112 } 113 114 static int sparse_parse_raw_chunk(sparse_header_t *sparse, 115 chunk_header_t *chunk) 116 { 117 unsigned int chunk_data_sz = sparse_get_chunk_data_size(sparse, chunk); 118 119 /* Check if the data size is a multiple of the main block size */ 120 if (chunk_data_sz % sparse->blk_sz) 121 return -EINVAL; 122 123 /* Check that the chunk size is consistent */ 124 if ((chunk_data_sz / sparse->blk_sz) != chunk->chunk_sz) 125 return -EINVAL; 126 127 return 0; 128 } 129 130 static chunk_header_t *sparse_parse_chunk(sparse_header_t *sparse, 131 void **image) 132 { 133 chunk_header_t *chunk = (chunk_header_t *) *image; 134 int ret; 135 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); 140 141 switch (chunk->chunk_type) { 142 case CHUNK_TYPE_RAW: 143 ret = sparse_parse_raw_chunk(sparse, chunk); 144 if (ret) 145 return NULL; 146 break; 147 148 case CHUNK_TYPE_FILL: 149 ret = sparse_parse_fill_chunk(sparse, chunk); 150 if (ret) 151 return NULL; 152 break; 153 154 case CHUNK_TYPE_DONT_CARE: 155 case CHUNK_TYPE_CRC32: 156 debug("Ignoring chunk\n"); 157 break; 158 159 default: 160 printf("%s: Unknown chunk type: %x\n", __func__, 161 chunk->chunk_type); 162 return NULL; 163 } 164 165 *image += sparse->chunk_hdr_sz; 166 167 return chunk; 168 } 169 170 static int sparse_get_fill_buffer(sparse_header_t *sparse, 171 chunk_header_t *chunk, 172 sparse_buffer_t *buffer, 173 unsigned int blk_sz, 174 void *data) 175 { 176 int i; 177 178 buffer->type = CHUNK_TYPE_FILL; 179 180 /* 181 * We create a buffer of one block, and ask it to be 182 * repeated as many times as needed. 183 */ 184 buffer->length = blk_sz; 185 buffer->repeat = (chunk->chunk_sz * sparse->blk_sz) / blk_sz; 186 187 buffer->data = memalign(ARCH_DMA_MINALIGN, 188 ROUNDUP(blk_sz, 189 ARCH_DMA_MINALIGN)); 190 if (!buffer->data) 191 return -ENOMEM; 192 193 for (i = 0; i < (buffer->length / sizeof(uint32_t)); i++) 194 ((uint32_t *)buffer->data)[i] = *(uint32_t *)(data); 195 196 return 0; 197 } 198 199 static int sparse_get_raw_buffer(sparse_header_t *sparse, 200 chunk_header_t *chunk, 201 sparse_buffer_t *buffer, 202 unsigned int blk_sz, 203 void *data) 204 { 205 unsigned int chunk_data_sz = sparse_get_chunk_data_size(sparse, chunk); 206 207 buffer->type = CHUNK_TYPE_RAW; 208 buffer->length = chunk_data_sz; 209 buffer->data = data; 210 buffer->repeat = 1; 211 212 return 0; 213 } 214 215 static sparse_buffer_t *sparse_get_data_buffer(sparse_header_t *sparse, 216 chunk_header_t *chunk, 217 unsigned int blk_sz, 218 void **image) 219 { 220 unsigned int chunk_data_sz = sparse_get_chunk_data_size(sparse, chunk); 221 sparse_buffer_t *buffer; 222 void *data = *image; 223 int ret; 224 225 *image += chunk_data_sz; 226 227 if (!sparse_chunk_has_buffer(chunk)) 228 return NULL; 229 230 buffer = calloc(sizeof(sparse_buffer_t), 1); 231 if (!buffer) 232 return NULL; 233 234 switch (chunk->chunk_type) { 235 case CHUNK_TYPE_RAW: 236 ret = sparse_get_raw_buffer(sparse, chunk, buffer, blk_sz, 237 data); 238 if (ret) 239 return NULL; 240 break; 241 242 case CHUNK_TYPE_FILL: 243 ret = sparse_get_fill_buffer(sparse, chunk, buffer, blk_sz, 244 data); 245 if (ret) 246 return NULL; 247 break; 248 249 default: 250 return NULL; 251 } 252 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); 258 259 return buffer; 260 } 261 262 static void sparse_put_data_buffer(sparse_buffer_t *buffer) 263 { 264 if (buffer->type == CHUNK_TYPE_FILL) 265 free(buffer->data); 266 267 free(buffer); 268 } 269 270 int store_sparse_image(sparse_storage_t *storage, void *storage_priv, 271 unsigned int session_id, void *data) 272 { 273 unsigned int chunk, offset; 274 sparse_header_t *sparse_header; 275 chunk_header_t *chunk_header; 276 sparse_buffer_t *buffer; 277 uint32_t start; 278 uint32_t total_blocks = 0; 279 int i; 280 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); 288 289 sparse_header = sparse_parse_header(&data); 290 if (!sparse_header) { 291 printf("sparse header issue\n"); 292 return -EINVAL; 293 } 294 295 /* 296 * Verify that the sparse block size is a multiple of our 297 * storage backend block size 298 */ 299 div_u64_rem(sparse_header->blk_sz, storage->block_sz, &offset); 300 if (offset) { 301 printf("%s: Sparse image block size issue [%u]\n", 302 __func__, sparse_header->blk_sz); 303 return -EINVAL; 304 } 305 306 /* 307 * If it's a new flashing session, start at the beginning of 308 * the partition. If not, then simply resume where we were. 309 */ 310 if (session_id > 0) 311 start = last_offset; 312 else 313 start = storage->start; 314 315 printf("Flashing sparse image on partition %s at offset 0x%x (ID: %d)\n", 316 storage->name, start * storage->block_sz, session_id); 317 318 /* Start processing chunks */ 319 for (chunk = 0; chunk < sparse_header->total_chunks; chunk++) { 320 uint32_t blkcnt; 321 322 chunk_header = sparse_parse_chunk(sparse_header, &data); 323 if (!chunk_header) { 324 printf("Unknown chunk type"); 325 return -EINVAL; 326 } 327 328 /* 329 * If we have a DONT_CARE type, just skip the blocks 330 * and go on parsing the rest of the chunks 331 */ 332 if (chunk_header->chunk_type == CHUNK_TYPE_DONT_CARE) { 333 blkcnt = sparse_block_size_to_storage(chunk_header->chunk_sz, 334 storage, 335 sparse_header); 336 #ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV 337 total_blocks += blkcnt; 338 #endif 339 continue; 340 } 341 342 /* Retrieve the buffer we're going to write */ 343 buffer = sparse_get_data_buffer(sparse_header, chunk_header, 344 storage->block_sz, &data); 345 if (!buffer) 346 continue; 347 348 blkcnt = (buffer->length / storage->block_sz) * buffer->repeat; 349 350 if ((start + total_blocks + blkcnt) > 351 (storage->start + storage->size)) { 352 printf("%s: Request would exceed partition size!\n", 353 __func__); 354 return -EINVAL; 355 } 356 357 for (i = 0; i < buffer->repeat; i++) { 358 unsigned long buffer_blk_cnt; 359 int ret; 360 361 buffer_blk_cnt = buffer->length / storage->block_sz; 362 363 ret = storage->write(storage, storage_priv, 364 start + total_blocks, 365 buffer_blk_cnt, 366 buffer->data); 367 if (ret < 0) { 368 printf("%s: Write %d failed %d\n", 369 __func__, i, ret); 370 return ret; 371 } 372 373 total_blocks += ret; 374 } 375 376 sparse_put_data_buffer(buffer); 377 } 378 379 debug("Wrote %d blocks, expected to write %d blocks\n", 380 total_blocks, 381 sparse_block_size_to_storage(sparse_header->total_blks, 382 storage, sparse_header)); 383 printf("........ wrote %d blocks to '%s'\n", total_blocks, 384 storage->name); 385 386 if (total_blocks != 387 sparse_block_size_to_storage(sparse_header->total_blks, 388 storage, sparse_header)) { 389 printf("sparse image write failure\n"); 390 return -EIO; 391 } 392 393 last_offset = start + total_blocks; 394 395 return 0; 396 } 397