fb_nand.c 6.0 KB

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