fb_nand.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright 2014 Broadcom Corporation.
  4. * Copyright 2015 Free Electrons.
  5. */
  6. #include <config.h>
  7. #include <common.h>
  8. #include <fastboot.h>
  9. #include <image-sparse.h>
  10. #include <linux/mtd/mtd.h>
  11. #include <jffs2/jffs2.h>
  12. #include <nand.h>
  13. struct fb_nand_sparse {
  14. struct mtd_info *mtd;
  15. struct part_info *part;
  16. };
  17. __weak int board_fastboot_erase_partition_setup(char *name)
  18. {
  19. return 0;
  20. }
  21. __weak int board_fastboot_write_partition_setup(char *name)
  22. {
  23. return 0;
  24. }
  25. static int fb_nand_lookup(const char *partname,
  26. struct mtd_info **mtd,
  27. struct part_info **part,
  28. char *response)
  29. {
  30. struct mtd_device *dev;
  31. int ret;
  32. u8 pnum;
  33. ret = mtdparts_init();
  34. if (ret) {
  35. pr_err("Cannot initialize MTD partitions\n");
  36. fastboot_fail("cannot init mtdparts", response);
  37. return ret;
  38. }
  39. ret = find_dev_and_part(partname, &dev, &pnum, part);
  40. if (ret) {
  41. pr_err("cannot find partition: '%s'", partname);
  42. fastboot_fail("cannot find partition", response);
  43. return ret;
  44. }
  45. if (dev->id->type != MTD_DEV_TYPE_NAND) {
  46. pr_err("partition '%s' is not stored on a NAND device",
  47. partname);
  48. fastboot_fail("not a NAND device", response);
  49. return -EINVAL;
  50. }
  51. *mtd = get_nand_dev_by_index(dev->id->num);
  52. return 0;
  53. }
  54. static int _fb_nand_erase(struct mtd_info *mtd, struct part_info *part)
  55. {
  56. nand_erase_options_t opts;
  57. int ret;
  58. memset(&opts, 0, sizeof(opts));
  59. opts.offset = part->offset;
  60. opts.length = part->size;
  61. opts.quiet = 1;
  62. printf("Erasing blocks 0x%llx to 0x%llx\n",
  63. part->offset, part->offset + part->size);
  64. ret = nand_erase_opts(mtd, &opts);
  65. if (ret)
  66. return ret;
  67. printf("........ erased 0x%llx bytes from '%s'\n",
  68. part->size, part->name);
  69. return 0;
  70. }
  71. static int _fb_nand_write(struct mtd_info *mtd, struct part_info *part,
  72. void *buffer, u32 offset,
  73. size_t length, size_t *written)
  74. {
  75. int flags = WITH_WR_VERIFY;
  76. #ifdef CONFIG_FASTBOOT_FLASH_NAND_TRIMFFS
  77. flags |= WITH_DROP_FFS;
  78. #endif
  79. return nand_write_skip_bad(mtd, offset, &length, written,
  80. part->size - (offset - part->offset),
  81. buffer, flags);
  82. }
  83. static lbaint_t fb_nand_sparse_write(struct sparse_storage *info,
  84. lbaint_t blk, lbaint_t blkcnt, const void *buffer)
  85. {
  86. struct fb_nand_sparse *sparse = info->priv;
  87. size_t written;
  88. int ret;
  89. ret = _fb_nand_write(sparse->mtd, sparse->part, (void *)buffer,
  90. blk * info->blksz,
  91. blkcnt * info->blksz, &written);
  92. if (ret < 0) {
  93. printf("Failed to write sparse chunk\n");
  94. return ret;
  95. }
  96. /* TODO - verify that the value "written" includes the "bad-blocks" ... */
  97. /*
  98. * the return value must be 'blkcnt' ("good-blocks") plus the
  99. * number of "bad-blocks" encountered within this space...
  100. */
  101. return written / info->blksz;
  102. }
  103. static lbaint_t fb_nand_sparse_reserve(struct sparse_storage *info,
  104. lbaint_t blk, lbaint_t blkcnt)
  105. {
  106. int bad_blocks = 0;
  107. /*
  108. * TODO - implement a function to determine the total number
  109. * of blocks which must be used in order to reserve the specified
  110. * number ("blkcnt") of "good-blocks", starting at "blk"...
  111. * ( possibly something like the "check_skip_len()" function )
  112. */
  113. /*
  114. * the return value must be 'blkcnt' ("good-blocks") plus the
  115. * number of "bad-blocks" encountered within this space...
  116. */
  117. return blkcnt + bad_blocks;
  118. }
  119. /**
  120. * fastboot_nand_get_part_info() - Lookup NAND partion by name
  121. *
  122. * @part_name: Named device to lookup
  123. * @part_info: Pointer to returned part_info pointer
  124. * @response: Pointer to fastboot response buffer
  125. */
  126. int fastboot_nand_get_part_info(const char *part_name,
  127. struct part_info **part_info, char *response)
  128. {
  129. struct mtd_info *mtd = NULL;
  130. return fb_nand_lookup(part_name, &mtd, part_info, response);
  131. }
  132. /**
  133. * fastboot_nand_flash_write() - Write image to NAND for fastboot
  134. *
  135. * @cmd: Named device to write image to
  136. * @download_buffer: Pointer to image data
  137. * @download_bytes: Size of image data
  138. * @response: Pointer to fastboot response buffer
  139. */
  140. void fastboot_nand_flash_write(const char *cmd, void *download_buffer,
  141. u32 download_bytes, char *response)
  142. {
  143. struct part_info *part;
  144. struct mtd_info *mtd = NULL;
  145. int ret;
  146. ret = fb_nand_lookup(cmd, &mtd, &part, response);
  147. if (ret) {
  148. pr_err("invalid NAND device");
  149. fastboot_fail("invalid NAND device", response);
  150. return;
  151. }
  152. ret = board_fastboot_write_partition_setup(part->name);
  153. if (ret)
  154. return;
  155. if (is_sparse_image(download_buffer)) {
  156. struct fb_nand_sparse sparse_priv;
  157. struct sparse_storage sparse;
  158. sparse_priv.mtd = mtd;
  159. sparse_priv.part = part;
  160. sparse.blksz = mtd->writesize;
  161. sparse.start = part->offset / sparse.blksz;
  162. sparse.size = part->size / sparse.blksz;
  163. sparse.write = fb_nand_sparse_write;
  164. sparse.reserve = fb_nand_sparse_reserve;
  165. sparse.mssg = fastboot_fail;
  166. printf("Flashing sparse image at offset " LBAFU "\n",
  167. sparse.start);
  168. sparse.priv = &sparse_priv;
  169. ret = write_sparse_image(&sparse, cmd, download_buffer,
  170. response);
  171. if (!ret)
  172. fastboot_okay(NULL, response);
  173. } else {
  174. printf("Flashing raw image at offset 0x%llx\n",
  175. part->offset);
  176. ret = _fb_nand_write(mtd, part, download_buffer, part->offset,
  177. download_bytes, NULL);
  178. printf("........ wrote %u bytes to '%s'\n",
  179. download_bytes, part->name);
  180. }
  181. if (ret) {
  182. fastboot_fail("error writing the image", response);
  183. return;
  184. }
  185. fastboot_okay(NULL, response);
  186. }
  187. /**
  188. * fastboot_nand_flash_erase() - Erase NAND for fastboot
  189. *
  190. * @cmd: Named device to erase
  191. * @response: Pointer to fastboot response buffer
  192. */
  193. void fastboot_nand_erase(const char *cmd, char *response)
  194. {
  195. struct part_info *part;
  196. struct mtd_info *mtd = NULL;
  197. int ret;
  198. ret = fb_nand_lookup(cmd, &mtd, &part, response);
  199. if (ret) {
  200. pr_err("invalid NAND device");
  201. fastboot_fail("invalid NAND device", response);
  202. return;
  203. }
  204. ret = board_fastboot_erase_partition_setup(part->name);
  205. if (ret)
  206. return;
  207. ret = _fb_nand_erase(mtd, part);
  208. if (ret) {
  209. pr_err("failed erasing from device %s", mtd->name);
  210. fastboot_fail("failed erasing from device", response);
  211. return;
  212. }
  213. fastboot_okay(NULL, response);
  214. }