image-sparse.c 7.9 KB

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