dfu_mmc.c 9.9 KB

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