dfu_mmc.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * dfu.c -- DFU back-end routines
  4. *
  5. * Copyright (C) 2012 Samsung Electronics
  6. * author: Lukasz Majewski <l.majewski@samsung.com>
  7. */
  8. #include <common.h>
  9. #include <malloc.h>
  10. #include <errno.h>
  11. #include <div64.h>
  12. #include <dfu.h>
  13. #include <ext4fs.h>
  14. #include <fat.h>
  15. #include <mmc.h>
  16. #include <part.h>
  17. static unsigned char *dfu_file_buf;
  18. static u64 dfu_file_buf_len;
  19. static u64 dfu_file_buf_offset;
  20. static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
  21. u64 offset, void *buf, long *len)
  22. {
  23. struct mmc *mmc;
  24. u32 blk_start, blk_count, n = 0;
  25. int ret, part_num_bkp = 0;
  26. mmc = find_mmc_device(dfu->data.mmc.dev_num);
  27. if (!mmc) {
  28. pr_err("Device MMC %d - not found!", dfu->data.mmc.dev_num);
  29. return -ENODEV;
  30. }
  31. /*
  32. * We must ensure that we work in lba_blk_size chunks, so ALIGN
  33. * this value.
  34. */
  35. *len = ALIGN(*len, dfu->data.mmc.lba_blk_size);
  36. blk_start = dfu->data.mmc.lba_start +
  37. (u32)lldiv(offset, dfu->data.mmc.lba_blk_size);
  38. blk_count = *len / dfu->data.mmc.lba_blk_size;
  39. if (blk_start + blk_count >
  40. dfu->data.mmc.lba_start + dfu->data.mmc.lba_size) {
  41. puts("Request would exceed designated area!\n");
  42. return -EINVAL;
  43. }
  44. if (dfu->data.mmc.hw_partition >= 0) {
  45. part_num_bkp = mmc_get_blk_desc(mmc)->hwpart;
  46. ret = blk_select_hwpart_devnum(IF_TYPE_MMC,
  47. dfu->data.mmc.dev_num,
  48. dfu->data.mmc.hw_partition);
  49. if (ret)
  50. return ret;
  51. }
  52. debug("%s: %s dev: %d start: %d cnt: %d buf: 0x%p\n", __func__,
  53. op == DFU_OP_READ ? "MMC READ" : "MMC WRITE",
  54. dfu->data.mmc.dev_num, blk_start, blk_count, buf);
  55. switch (op) {
  56. case DFU_OP_READ:
  57. n = blk_dread(mmc_get_blk_desc(mmc), blk_start, blk_count, buf);
  58. break;
  59. case DFU_OP_WRITE:
  60. n = blk_dwrite(mmc_get_blk_desc(mmc), blk_start, blk_count,
  61. buf);
  62. break;
  63. default:
  64. pr_err("Operation not supported\n");
  65. }
  66. if (n != blk_count) {
  67. pr_err("MMC operation failed");
  68. if (dfu->data.mmc.hw_partition >= 0)
  69. blk_select_hwpart_devnum(IF_TYPE_MMC,
  70. dfu->data.mmc.dev_num,
  71. part_num_bkp);
  72. return -EIO;
  73. }
  74. if (dfu->data.mmc.hw_partition >= 0) {
  75. ret = blk_select_hwpart_devnum(IF_TYPE_MMC,
  76. dfu->data.mmc.dev_num,
  77. part_num_bkp);
  78. if (ret)
  79. return ret;
  80. }
  81. return 0;
  82. }
  83. static int mmc_file_op(enum dfu_op op, struct dfu_entity *dfu,
  84. u64 offset, void *buf, u64 *len)
  85. {
  86. char dev_part_str[8];
  87. int ret;
  88. int fstype;
  89. loff_t size = 0;
  90. switch (dfu->layout) {
  91. case DFU_FS_FAT:
  92. fstype = FS_TYPE_FAT;
  93. break;
  94. case DFU_FS_EXT4:
  95. fstype = FS_TYPE_EXT;
  96. break;
  97. default:
  98. printf("%s: Layout (%s) not (yet) supported!\n", __func__,
  99. dfu_get_layout(dfu->layout));
  100. return -1;
  101. }
  102. snprintf(dev_part_str, sizeof(dev_part_str), "%d:%d",
  103. dfu->data.mmc.dev, dfu->data.mmc.part);
  104. ret = fs_set_blk_dev("mmc", dev_part_str, fstype);
  105. if (ret) {
  106. puts("dfu: fs_set_blk_dev error!\n");
  107. return ret;
  108. }
  109. switch (op) {
  110. case DFU_OP_READ:
  111. ret = fs_read(dfu->name, (size_t)buf, offset, *len, &size);
  112. if (ret) {
  113. puts("dfu: fs_read error!\n");
  114. return ret;
  115. }
  116. *len = size;
  117. break;
  118. case DFU_OP_WRITE:
  119. ret = fs_write(dfu->name, (size_t)buf, offset, *len, &size);
  120. if (ret) {
  121. puts("dfu: fs_write error!\n");
  122. return ret;
  123. }
  124. break;
  125. case DFU_OP_SIZE:
  126. ret = fs_size(dfu->name, &size);
  127. if (ret) {
  128. puts("dfu: fs_size error!\n");
  129. return ret;
  130. }
  131. *len = size;
  132. break;
  133. default:
  134. return -1;
  135. }
  136. return ret;
  137. }
  138. static int mmc_file_buf_write(struct dfu_entity *dfu, u64 offset, void *buf, long *len)
  139. {
  140. int ret = 0;
  141. if (offset == 0) {
  142. dfu_file_buf_len = 0;
  143. dfu_file_buf_offset = 0;
  144. }
  145. /* Add to the current buffer. */
  146. if (dfu_file_buf_len + *len > CONFIG_SYS_DFU_MAX_FILE_SIZE)
  147. *len = CONFIG_SYS_DFU_MAX_FILE_SIZE - dfu_file_buf_len;
  148. memcpy(dfu_file_buf + dfu_file_buf_len, buf, *len);
  149. dfu_file_buf_len += *len;
  150. if (dfu_file_buf_len == CONFIG_SYS_DFU_MAX_FILE_SIZE) {
  151. ret = mmc_file_op(DFU_OP_WRITE, dfu, dfu_file_buf_offset,
  152. dfu_file_buf, &dfu_file_buf_len);
  153. dfu_file_buf_offset += dfu_file_buf_len;
  154. dfu_file_buf_len = 0;
  155. }
  156. return ret;
  157. }
  158. static int mmc_file_buf_write_finish(struct dfu_entity *dfu)
  159. {
  160. int ret = mmc_file_op(DFU_OP_WRITE, dfu, dfu_file_buf_offset,
  161. dfu_file_buf, &dfu_file_buf_len);
  162. /* Now that we're done */
  163. dfu_file_buf_len = 0;
  164. dfu_file_buf_offset = 0;
  165. return ret;
  166. }
  167. int dfu_write_medium_mmc(struct dfu_entity *dfu,
  168. u64 offset, void *buf, long *len)
  169. {
  170. int ret = -1;
  171. switch (dfu->layout) {
  172. case DFU_RAW_ADDR:
  173. ret = mmc_block_op(DFU_OP_WRITE, dfu, offset, buf, len);
  174. break;
  175. case DFU_FS_FAT:
  176. case DFU_FS_EXT4:
  177. ret = mmc_file_buf_write(dfu, offset, buf, len);
  178. break;
  179. default:
  180. printf("%s: Layout (%s) not (yet) supported!\n", __func__,
  181. dfu_get_layout(dfu->layout));
  182. }
  183. return ret;
  184. }
  185. int dfu_flush_medium_mmc(struct dfu_entity *dfu)
  186. {
  187. int ret = 0;
  188. if (dfu->layout != DFU_RAW_ADDR) {
  189. /* Do stuff here. */
  190. ret = mmc_file_buf_write_finish(dfu);
  191. }
  192. return ret;
  193. }
  194. int dfu_get_medium_size_mmc(struct dfu_entity *dfu, u64 *size)
  195. {
  196. int ret;
  197. switch (dfu->layout) {
  198. case DFU_RAW_ADDR:
  199. *size = dfu->data.mmc.lba_size * dfu->data.mmc.lba_blk_size;
  200. return 0;
  201. case DFU_FS_FAT:
  202. case DFU_FS_EXT4:
  203. ret = mmc_file_op(DFU_OP_SIZE, dfu, 0, NULL, size);
  204. if (ret < 0)
  205. return ret;
  206. return 0;
  207. default:
  208. printf("%s: Layout (%s) not (yet) supported!\n", __func__,
  209. dfu_get_layout(dfu->layout));
  210. return -1;
  211. }
  212. }
  213. static int mmc_file_buf_read(struct dfu_entity *dfu, u64 offset, void *buf,
  214. long *len)
  215. {
  216. int ret;
  217. if (offset == 0 || offset >= dfu_file_buf_offset + dfu_file_buf_len ||
  218. offset + *len < dfu_file_buf_offset) {
  219. u64 file_len = CONFIG_SYS_DFU_MAX_FILE_SIZE;
  220. ret = mmc_file_op(DFU_OP_READ, dfu, offset, dfu_file_buf,
  221. &file_len);
  222. if (ret < 0)
  223. return ret;
  224. dfu_file_buf_len = file_len;
  225. dfu_file_buf_offset = offset;
  226. }
  227. if (offset + *len > dfu_file_buf_offset + dfu_file_buf_len)
  228. return -EINVAL;
  229. /* Add to the current buffer. */
  230. memcpy(buf, dfu_file_buf + offset - dfu_file_buf_offset, *len);
  231. return 0;
  232. }
  233. int dfu_read_medium_mmc(struct dfu_entity *dfu, u64 offset, void *buf,
  234. long *len)
  235. {
  236. int ret = -1;
  237. switch (dfu->layout) {
  238. case DFU_RAW_ADDR:
  239. ret = mmc_block_op(DFU_OP_READ, dfu, offset, buf, len);
  240. break;
  241. case DFU_FS_FAT:
  242. case DFU_FS_EXT4:
  243. ret = mmc_file_buf_read(dfu, offset, buf, len);
  244. break;
  245. default:
  246. printf("%s: Layout (%s) not (yet) supported!\n", __func__,
  247. dfu_get_layout(dfu->layout));
  248. }
  249. return ret;
  250. }
  251. void dfu_free_entity_mmc(struct dfu_entity *dfu)
  252. {
  253. if (dfu_file_buf) {
  254. free(dfu_file_buf);
  255. dfu_file_buf = NULL;
  256. }
  257. }
  258. /*
  259. * @param s Parameter string containing space-separated arguments:
  260. * 1st:
  261. * raw (raw read/write)
  262. * fat (files)
  263. * ext4 (^)
  264. * part (partition image)
  265. * 2nd and 3rd:
  266. * lba_start and lba_size, for raw write
  267. * mmc_dev and mmc_part, for filesystems and part
  268. * 4th (optional):
  269. * mmcpart <num> (access to HW eMMC partitions)
  270. */
  271. int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
  272. {
  273. const char *entity_type;
  274. size_t second_arg;
  275. size_t third_arg;
  276. struct mmc *mmc;
  277. const char *argv[3];
  278. const char **parg = argv;
  279. dfu->data.mmc.dev_num = simple_strtoul(devstr, NULL, 10);
  280. for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
  281. *parg = strsep(&s, " ");
  282. if (*parg == NULL) {
  283. pr_err("Invalid number of arguments.\n");
  284. return -ENODEV;
  285. }
  286. }
  287. entity_type = argv[0];
  288. /*
  289. * Base 0 means we'll accept (prefixed with 0x or 0) base 16, 8,
  290. * with default 10.
  291. */
  292. second_arg = simple_strtoul(argv[1], NULL, 0);
  293. third_arg = simple_strtoul(argv[2], NULL, 0);
  294. mmc = find_mmc_device(dfu->data.mmc.dev_num);
  295. if (mmc == NULL) {
  296. pr_err("Couldn't find MMC device no. %d.\n",
  297. dfu->data.mmc.dev_num);
  298. return -ENODEV;
  299. }
  300. if (mmc_init(mmc)) {
  301. pr_err("Couldn't init MMC device.\n");
  302. return -ENODEV;
  303. }
  304. dfu->data.mmc.hw_partition = -EINVAL;
  305. if (!strcmp(entity_type, "raw")) {
  306. dfu->layout = DFU_RAW_ADDR;
  307. dfu->data.mmc.lba_start = second_arg;
  308. dfu->data.mmc.lba_size = third_arg;
  309. dfu->data.mmc.lba_blk_size = mmc->read_bl_len;
  310. /*
  311. * Check for an extra entry at dfu_alt_info env variable
  312. * specifying the mmc HW defined partition number
  313. */
  314. if (s)
  315. if (!strcmp(strsep(&s, " "), "mmcpart"))
  316. dfu->data.mmc.hw_partition =
  317. simple_strtoul(s, NULL, 0);
  318. } else if (!strcmp(entity_type, "part")) {
  319. struct disk_partition partinfo;
  320. struct blk_desc *blk_dev = mmc_get_blk_desc(mmc);
  321. int mmcdev = second_arg;
  322. int mmcpart = third_arg;
  323. int offset = 0;
  324. if (part_get_info(blk_dev, mmcpart, &partinfo) != 0) {
  325. pr_err("Couldn't find part #%d on mmc device #%d\n",
  326. mmcpart, mmcdev);
  327. return -ENODEV;
  328. }
  329. /*
  330. * Check for an extra entry at dfu_alt_info env variable
  331. * specifying the mmc HW defined partition number
  332. */
  333. if (s)
  334. if (!strcmp(strsep(&s, " "), "offset"))
  335. offset = simple_strtoul(s, NULL, 0);
  336. dfu->layout = DFU_RAW_ADDR;
  337. dfu->data.mmc.lba_start = partinfo.start + offset;
  338. dfu->data.mmc.lba_size = partinfo.size-offset;
  339. dfu->data.mmc.lba_blk_size = partinfo.blksz;
  340. } else if (!strcmp(entity_type, "fat")) {
  341. dfu->layout = DFU_FS_FAT;
  342. } else if (!strcmp(entity_type, "ext4")) {
  343. dfu->layout = DFU_FS_EXT4;
  344. } else {
  345. pr_err("Memory layout (%s) not supported!\n", entity_type);
  346. return -ENODEV;
  347. }
  348. /* if it's NOT a raw write */
  349. if (strcmp(entity_type, "raw")) {
  350. dfu->data.mmc.dev = second_arg;
  351. dfu->data.mmc.part = third_arg;
  352. }
  353. dfu->dev_type = DFU_DEV_MMC;
  354. dfu->get_medium_size = dfu_get_medium_size_mmc;
  355. dfu->read_medium = dfu_read_medium_mmc;
  356. dfu->write_medium = dfu_write_medium_mmc;
  357. dfu->flush_medium = dfu_flush_medium_mmc;
  358. dfu->inited = 0;
  359. dfu->free_entity = dfu_free_entity_mmc;
  360. /* Check if file buffer is ready */
  361. if (!dfu_file_buf) {
  362. dfu_file_buf = memalign(CONFIG_SYS_CACHELINE_SIZE,
  363. CONFIG_SYS_DFU_MAX_FILE_SIZE);
  364. if (!dfu_file_buf) {
  365. pr_err("Could not memalign 0x%x bytes",
  366. CONFIG_SYS_DFU_MAX_FILE_SIZE);
  367. return -ENOMEM;
  368. }
  369. }
  370. return 0;
  371. }