image-sparse.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264
  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 <blk.h>
  39. #include <image-sparse.h>
  40. #include <div64.h>
  41. #include <log.h>
  42. #include <malloc.h>
  43. #include <part.h>
  44. #include <sparse_format.h>
  45. #include <asm/cache.h>
  46. #include <linux/math64.h>
  47. static void default_log(const char *ignored, char *response) {}
  48. int write_sparse_image(struct sparse_storage *info,
  49. const char *part_name, void *data, char *response)
  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_IMAGE_SPARSE_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", response);
  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. response);
  128. return -1;
  129. }
  130. if (blk + blkcnt > info->start + info->size) {
  131. printf(
  132. "%s: Request would exceed partition size!\n",
  133. __func__);
  134. info->mssg("Request would exceed partition size!",
  135. response);
  136. return -1;
  137. }
  138. blks = info->write(info, blk, blkcnt, data);
  139. /* blks might be > blkcnt (eg. NAND bad-blocks) */
  140. if (blks < blkcnt) {
  141. printf("%s: %s" LBAFU " [" LBAFU "]\n",
  142. __func__, "Write failed, block #",
  143. blk, blks);
  144. info->mssg("flash write failure", response);
  145. return -1;
  146. }
  147. blk += blks;
  148. bytes_written += blkcnt * info->blksz;
  149. total_blocks += chunk_header->chunk_sz;
  150. data += chunk_data_sz;
  151. break;
  152. case CHUNK_TYPE_FILL:
  153. if (chunk_header->total_sz !=
  154. (sparse_header->chunk_hdr_sz + sizeof(uint32_t))) {
  155. info->mssg("Bogus chunk size for chunk type FILL", response);
  156. return -1;
  157. }
  158. fill_buf = (uint32_t *)
  159. memalign(ARCH_DMA_MINALIGN,
  160. ROUNDUP(
  161. info->blksz * fill_buf_num_blks,
  162. ARCH_DMA_MINALIGN));
  163. if (!fill_buf) {
  164. info->mssg("Malloc failed for: CHUNK_TYPE_FILL",
  165. response);
  166. return -1;
  167. }
  168. fill_val = *(uint32_t *)data;
  169. data = (char *)data + sizeof(uint32_t);
  170. for (i = 0;
  171. i < (info->blksz * fill_buf_num_blks /
  172. sizeof(fill_val));
  173. i++)
  174. fill_buf[i] = fill_val;
  175. if (blk + blkcnt > info->start + info->size) {
  176. printf(
  177. "%s: Request would exceed partition size!\n",
  178. __func__);
  179. info->mssg("Request would exceed partition size!",
  180. response);
  181. return -1;
  182. }
  183. for (i = 0; i < blkcnt;) {
  184. j = blkcnt - i;
  185. if (j > fill_buf_num_blks)
  186. j = fill_buf_num_blks;
  187. blks = info->write(info, blk, j, fill_buf);
  188. /* blks might be > j (eg. NAND bad-blocks) */
  189. if (blks < j) {
  190. printf("%s: %s " LBAFU " [%d]\n",
  191. __func__,
  192. "Write failed, block #",
  193. blk, j);
  194. info->mssg("flash write failure",
  195. response);
  196. free(fill_buf);
  197. return -1;
  198. }
  199. blk += blks;
  200. i += j;
  201. }
  202. bytes_written += blkcnt * info->blksz;
  203. total_blocks += chunk_data_sz / sparse_header->blk_sz;
  204. free(fill_buf);
  205. break;
  206. case CHUNK_TYPE_DONT_CARE:
  207. blk += info->reserve(info, blk, blkcnt);
  208. total_blocks += chunk_header->chunk_sz;
  209. break;
  210. case CHUNK_TYPE_CRC32:
  211. if (chunk_header->total_sz !=
  212. sparse_header->chunk_hdr_sz) {
  213. info->mssg("Bogus chunk size for chunk type Dont Care",
  214. response);
  215. return -1;
  216. }
  217. total_blocks += chunk_header->chunk_sz;
  218. data += chunk_data_sz;
  219. break;
  220. default:
  221. printf("%s: Unknown chunk type: %x\n", __func__,
  222. chunk_header->chunk_type);
  223. info->mssg("Unknown chunk type", response);
  224. return -1;
  225. }
  226. }
  227. debug("Wrote %d blocks, expected to write %d blocks\n",
  228. total_blocks, sparse_header->total_blks);
  229. printf("........ wrote %u bytes to '%s'\n", bytes_written, part_name);
  230. if (total_blocks != sparse_header->total_blks) {
  231. info->mssg("sparse image write failure", response);
  232. return -1;
  233. }
  234. return 0;
  235. }