dfu_mmc.c 11 KB

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