dfu_mmc.c 9.2 KB

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