fb_nand.c 6.0 KB

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