image-sparse.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259
  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. #include <config.h>
  37. #include <common.h>
  38. #include <image-sparse.h>
  39. #include <div64.h>
  40. #include <malloc.h>
  41. #include <part.h>
  42. #include <sparse_format.h>
  43. #include <linux/math64.h>
  44. #ifndef CONFIG_FASTBOOT_FLASH_FILLBUF_SIZE
  45. #define CONFIG_FASTBOOT_FLASH_FILLBUF_SIZE (1024 * 512)
  46. #endif
  47. static void default_log(const char *ignored) {}
  48. int write_sparse_image(struct sparse_storage *info,
  49. const char *part_name, void *data)
  50. {
  51. lbaint_t blk;
  52. lbaint_t blkcnt;
  53. lbaint_t blks;
  54. uint32_t bytes_written = 0;
  55. unsigned int chunk;
  56. unsigned int offset;
  57. unsigned int chunk_data_sz;
  58. uint32_t *fill_buf = NULL;
  59. uint32_t fill_val;
  60. sparse_header_t *sparse_header;
  61. chunk_header_t *chunk_header;
  62. uint32_t total_blocks = 0;
  63. int fill_buf_num_blks;
  64. int i;
  65. int j;
  66. fill_buf_num_blks = CONFIG_FASTBOOT_FLASH_FILLBUF_SIZE / info->blksz;
  67. /* Read and skip over sparse image header */
  68. sparse_header = (sparse_header_t *)data;
  69. data += sparse_header->file_hdr_sz;
  70. if (sparse_header->file_hdr_sz > sizeof(sparse_header_t)) {
  71. /*
  72. * Skip the remaining bytes in a header that is longer than
  73. * we expected.
  74. */
  75. data += (sparse_header->file_hdr_sz - sizeof(sparse_header_t));
  76. }
  77. if (!info->mssg)
  78. info->mssg = default_log;
  79. debug("=== Sparse Image Header ===\n");
  80. debug("magic: 0x%x\n", sparse_header->magic);
  81. debug("major_version: 0x%x\n", sparse_header->major_version);
  82. debug("minor_version: 0x%x\n", sparse_header->minor_version);
  83. debug("file_hdr_sz: %d\n", sparse_header->file_hdr_sz);
  84. debug("chunk_hdr_sz: %d\n", sparse_header->chunk_hdr_sz);
  85. debug("blk_sz: %d\n", sparse_header->blk_sz);
  86. debug("total_blks: %d\n", sparse_header->total_blks);
  87. debug("total_chunks: %d\n", sparse_header->total_chunks);
  88. /*
  89. * Verify that the sparse block size is a multiple of our
  90. * storage backend block size
  91. */
  92. div_u64_rem(sparse_header->blk_sz, info->blksz, &offset);
  93. if (offset) {
  94. printf("%s: Sparse image block size issue [%u]\n",
  95. __func__, sparse_header->blk_sz);
  96. info->mssg("sparse image block size issue");
  97. return -1;
  98. }
  99. puts("Flashing Sparse Image\n");
  100. /* Start processing chunks */
  101. blk = info->start;
  102. for (chunk = 0; chunk < sparse_header->total_chunks; chunk++) {
  103. /* Read and skip over chunk header */
  104. chunk_header = (chunk_header_t *)data;
  105. data += sizeof(chunk_header_t);
  106. if (chunk_header->chunk_type != CHUNK_TYPE_RAW) {
  107. debug("=== Chunk Header ===\n");
  108. debug("chunk_type: 0x%x\n", chunk_header->chunk_type);
  109. debug("chunk_data_sz: 0x%x\n", chunk_header->chunk_sz);
  110. debug("total_size: 0x%x\n", chunk_header->total_sz);
  111. }
  112. if (sparse_header->chunk_hdr_sz > sizeof(chunk_header_t)) {
  113. /*
  114. * Skip the remaining bytes in a header that is longer
  115. * than we expected.
  116. */
  117. data += (sparse_header->chunk_hdr_sz -
  118. sizeof(chunk_header_t));
  119. }
  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) {
  123. case CHUNK_TYPE_RAW:
  124. if (chunk_header->total_sz !=
  125. (sparse_header->chunk_hdr_sz + chunk_data_sz)) {
  126. info->mssg("Bogus chunk size for chunk type Raw");
  127. return -1;
  128. }
  129. if (blk + blkcnt > info->start + info->size) {
  130. printf(
  131. "%s: Request would exceed partition size!\n",
  132. __func__);
  133. info->mssg("Request would exceed partition size!");
  134. return -1;
  135. }
  136. blks = info->write(info, blk, blkcnt, data);
  137. /* blks might be > blkcnt (eg. NAND bad-blocks) */
  138. if (blks < blkcnt) {
  139. printf("%s: %s" LBAFU " [" LBAFU "]\n",
  140. __func__, "Write failed, block #",
  141. blk, blks);
  142. info->mssg("flash write failure");
  143. return -1;
  144. }
  145. blk += blks;
  146. bytes_written += blkcnt * info->blksz;
  147. total_blocks += chunk_header->chunk_sz;
  148. data += chunk_data_sz;
  149. break;
  150. case CHUNK_TYPE_FILL:
  151. if (chunk_header->total_sz !=
  152. (sparse_header->chunk_hdr_sz + sizeof(uint32_t))) {
  153. info->mssg("Bogus chunk size for chunk type FILL");
  154. return -1;
  155. }
  156. fill_buf = (uint32_t *)
  157. memalign(ARCH_DMA_MINALIGN,
  158. ROUNDUP(
  159. info->blksz * fill_buf_num_blks,
  160. ARCH_DMA_MINALIGN));
  161. if (!fill_buf) {
  162. info->mssg("Malloc failed for: CHUNK_TYPE_FILL");
  163. return -1;
  164. }
  165. fill_val = *(uint32_t *)data;
  166. data = (char *)data + sizeof(uint32_t);
  167. for (i = 0;
  168. i < (info->blksz * fill_buf_num_blks /
  169. sizeof(fill_val));
  170. i++)
  171. fill_buf[i] = fill_val;
  172. if (blk + blkcnt > info->start + info->size) {
  173. printf(
  174. "%s: Request would exceed partition size!\n",
  175. __func__);
  176. info->mssg("Request would exceed partition size!");
  177. return -1;
  178. }
  179. for (i = 0; i < blkcnt;) {
  180. j = blkcnt - i;
  181. if (j > fill_buf_num_blks)
  182. j = fill_buf_num_blks;
  183. blks = info->write(info, blk, j, fill_buf);
  184. /* blks might be > j (eg. NAND bad-blocks) */
  185. if (blks < j) {
  186. printf("%s: %s " LBAFU " [%d]\n",
  187. __func__,
  188. "Write failed, block #",
  189. blk, j);
  190. info->mssg("flash write failure");
  191. free(fill_buf);
  192. return -1;
  193. }
  194. blk += blks;
  195. i += j;
  196. }
  197. bytes_written += blkcnt * info->blksz;
  198. total_blocks += chunk_data_sz / sparse_header->blk_sz;
  199. free(fill_buf);
  200. break;
  201. case CHUNK_TYPE_DONT_CARE:
  202. blk += info->reserve(info, blk, blkcnt);
  203. total_blocks += chunk_header->chunk_sz;
  204. break;
  205. case CHUNK_TYPE_CRC32:
  206. if (chunk_header->total_sz !=
  207. sparse_header->chunk_hdr_sz) {
  208. info->mssg("Bogus chunk size for chunk type Dont Care");
  209. return -1;
  210. }
  211. total_blocks += chunk_header->chunk_sz;
  212. data += chunk_data_sz;
  213. break;
  214. default:
  215. printf("%s: Unknown chunk type: %x\n", __func__,
  216. chunk_header->chunk_type);
  217. info->mssg("Unknown chunk type");
  218. return -1;
  219. }
  220. }
  221. debug("Wrote %d blocks, expected to write %d blocks\n",
  222. total_blocks, sparse_header->total_blks);
  223. printf("........ wrote %u bytes to '%s'\n", bytes_written, part_name);
  224. if (total_blocks != sparse_header->total_blks) {
  225. info->mssg("sparse image write failure");
  226. return -1;
  227. }
  228. return 0;
  229. }