mmc.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823
  1. /*
  2. * (C) Copyright 2003
  3. * Kyle Harris, kharris@nexus-tech.net
  4. *
  5. * SPDX-License-Identifier: GPL-2.0+
  6. */
  7. #include <common.h>
  8. #include <command.h>
  9. #include <console.h>
  10. #include <mmc.h>
  11. static int curr_device = -1;
  12. static void print_mmcinfo(struct mmc *mmc)
  13. {
  14. int i;
  15. printf("Device: %s\n", mmc->cfg->name);
  16. printf("Manufacturer ID: %x\n", mmc->cid[0] >> 24);
  17. printf("OEM: %x\n", (mmc->cid[0] >> 8) & 0xffff);
  18. printf("Name: %c%c%c%c%c \n", mmc->cid[0] & 0xff,
  19. (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
  20. (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
  21. printf("Tran Speed: %d\n", mmc->tran_speed);
  22. printf("Rd Block Len: %d\n", mmc->read_bl_len);
  23. printf("%s version %d.%d", IS_SD(mmc) ? "SD" : "MMC",
  24. EXTRACT_SDMMC_MAJOR_VERSION(mmc->version),
  25. EXTRACT_SDMMC_MINOR_VERSION(mmc->version));
  26. if (EXTRACT_SDMMC_CHANGE_VERSION(mmc->version) != 0)
  27. printf(".%d", EXTRACT_SDMMC_CHANGE_VERSION(mmc->version));
  28. printf("\n");
  29. printf("High Capacity: %s\n", mmc->high_capacity ? "Yes" : "No");
  30. puts("Capacity: ");
  31. print_size(mmc->capacity, "\n");
  32. printf("Bus Width: %d-bit%s\n", mmc->bus_width,
  33. mmc->ddr_mode ? " DDR" : "");
  34. puts("Erase Group Size: ");
  35. print_size(((u64)mmc->erase_grp_size) << 9, "\n");
  36. if (!IS_SD(mmc) && mmc->version >= MMC_VERSION_4_41) {
  37. bool has_enh = (mmc->part_support & ENHNCD_SUPPORT) != 0;
  38. bool usr_enh = has_enh && (mmc->part_attr & EXT_CSD_ENH_USR);
  39. puts("HC WP Group Size: ");
  40. print_size(((u64)mmc->hc_wp_grp_size) << 9, "\n");
  41. puts("User Capacity: ");
  42. print_size(mmc->capacity_user, usr_enh ? " ENH" : "");
  43. if (mmc->wr_rel_set & EXT_CSD_WR_DATA_REL_USR)
  44. puts(" WRREL\n");
  45. else
  46. putc('\n');
  47. if (usr_enh) {
  48. puts("User Enhanced Start: ");
  49. print_size(mmc->enh_user_start, "\n");
  50. puts("User Enhanced Size: ");
  51. print_size(mmc->enh_user_size, "\n");
  52. }
  53. puts("Boot Capacity: ");
  54. print_size(mmc->capacity_boot, has_enh ? " ENH\n" : "\n");
  55. puts("RPMB Capacity: ");
  56. print_size(mmc->capacity_rpmb, has_enh ? " ENH\n" : "\n");
  57. for (i = 0; i < ARRAY_SIZE(mmc->capacity_gp); i++) {
  58. bool is_enh = has_enh &&
  59. (mmc->part_attr & EXT_CSD_ENH_GP(i));
  60. if (mmc->capacity_gp[i]) {
  61. printf("GP%i Capacity: ", i+1);
  62. print_size(mmc->capacity_gp[i],
  63. is_enh ? " ENH" : "");
  64. if (mmc->wr_rel_set & EXT_CSD_WR_DATA_REL_GP(i))
  65. puts(" WRREL\n");
  66. else
  67. putc('\n');
  68. }
  69. }
  70. }
  71. }
  72. static struct mmc *init_mmc_device(int dev, bool force_init)
  73. {
  74. struct mmc *mmc;
  75. mmc = find_mmc_device(dev);
  76. if (!mmc) {
  77. printf("no mmc device at slot %x\n", dev);
  78. return NULL;
  79. }
  80. if (force_init)
  81. mmc->has_init = 0;
  82. if (mmc_init(mmc))
  83. return NULL;
  84. return mmc;
  85. }
  86. static int do_mmcinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  87. {
  88. struct mmc *mmc;
  89. if (curr_device < 0) {
  90. if (get_mmc_num() > 0)
  91. curr_device = 0;
  92. else {
  93. puts("No MMC device available\n");
  94. return 1;
  95. }
  96. }
  97. mmc = init_mmc_device(curr_device, false);
  98. if (!mmc)
  99. return CMD_RET_FAILURE;
  100. print_mmcinfo(mmc);
  101. return CMD_RET_SUCCESS;
  102. }
  103. #ifdef CONFIG_SUPPORT_EMMC_RPMB
  104. static int confirm_key_prog(void)
  105. {
  106. puts("Warning: Programming authentication key can be done only once !\n"
  107. " Use this command only if you are sure of what you are doing,\n"
  108. "Really perform the key programming? <y/N> ");
  109. if (confirm_yesno())
  110. return 1;
  111. puts("Authentication key programming aborted\n");
  112. return 0;
  113. }
  114. static int do_mmcrpmb_key(cmd_tbl_t *cmdtp, int flag,
  115. int argc, char * const argv[])
  116. {
  117. void *key_addr;
  118. struct mmc *mmc = find_mmc_device(curr_device);
  119. if (argc != 2)
  120. return CMD_RET_USAGE;
  121. key_addr = (void *)simple_strtoul(argv[1], NULL, 16);
  122. if (!confirm_key_prog())
  123. return CMD_RET_FAILURE;
  124. if (mmc_rpmb_set_key(mmc, key_addr)) {
  125. printf("ERROR - Key already programmed ?\n");
  126. return CMD_RET_FAILURE;
  127. }
  128. return CMD_RET_SUCCESS;
  129. }
  130. static int do_mmcrpmb_read(cmd_tbl_t *cmdtp, int flag,
  131. int argc, char * const argv[])
  132. {
  133. u16 blk, cnt;
  134. void *addr;
  135. int n;
  136. void *key_addr = NULL;
  137. struct mmc *mmc = find_mmc_device(curr_device);
  138. if (argc < 4)
  139. return CMD_RET_USAGE;
  140. addr = (void *)simple_strtoul(argv[1], NULL, 16);
  141. blk = simple_strtoul(argv[2], NULL, 16);
  142. cnt = simple_strtoul(argv[3], NULL, 16);
  143. if (argc == 5)
  144. key_addr = (void *)simple_strtoul(argv[4], NULL, 16);
  145. printf("\nMMC RPMB read: dev # %d, block # %d, count %d ... ",
  146. curr_device, blk, cnt);
  147. n = mmc_rpmb_read(mmc, addr, blk, cnt, key_addr);
  148. printf("%d RPMB blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
  149. if (n != cnt)
  150. return CMD_RET_FAILURE;
  151. return CMD_RET_SUCCESS;
  152. }
  153. static int do_mmcrpmb_write(cmd_tbl_t *cmdtp, int flag,
  154. int argc, char * const argv[])
  155. {
  156. u16 blk, cnt;
  157. void *addr;
  158. int n;
  159. void *key_addr;
  160. struct mmc *mmc = find_mmc_device(curr_device);
  161. if (argc != 5)
  162. return CMD_RET_USAGE;
  163. addr = (void *)simple_strtoul(argv[1], NULL, 16);
  164. blk = simple_strtoul(argv[2], NULL, 16);
  165. cnt = simple_strtoul(argv[3], NULL, 16);
  166. key_addr = (void *)simple_strtoul(argv[4], NULL, 16);
  167. printf("\nMMC RPMB write: dev # %d, block # %d, count %d ... ",
  168. curr_device, blk, cnt);
  169. n = mmc_rpmb_write(mmc, addr, blk, cnt, key_addr);
  170. printf("%d RPMB blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
  171. if (n != cnt)
  172. return CMD_RET_FAILURE;
  173. return CMD_RET_SUCCESS;
  174. }
  175. static int do_mmcrpmb_counter(cmd_tbl_t *cmdtp, int flag,
  176. int argc, char * const argv[])
  177. {
  178. unsigned long counter;
  179. struct mmc *mmc = find_mmc_device(curr_device);
  180. if (mmc_rpmb_get_counter(mmc, &counter))
  181. return CMD_RET_FAILURE;
  182. printf("RPMB Write counter= %lx\n", counter);
  183. return CMD_RET_SUCCESS;
  184. }
  185. static cmd_tbl_t cmd_rpmb[] = {
  186. U_BOOT_CMD_MKENT(key, 2, 0, do_mmcrpmb_key, "", ""),
  187. U_BOOT_CMD_MKENT(read, 5, 1, do_mmcrpmb_read, "", ""),
  188. U_BOOT_CMD_MKENT(write, 5, 0, do_mmcrpmb_write, "", ""),
  189. U_BOOT_CMD_MKENT(counter, 1, 1, do_mmcrpmb_counter, "", ""),
  190. };
  191. static int do_mmcrpmb(cmd_tbl_t *cmdtp, int flag,
  192. int argc, char * const argv[])
  193. {
  194. cmd_tbl_t *cp;
  195. struct mmc *mmc;
  196. char original_part;
  197. int ret;
  198. cp = find_cmd_tbl(argv[1], cmd_rpmb, ARRAY_SIZE(cmd_rpmb));
  199. /* Drop the rpmb subcommand */
  200. argc--;
  201. argv++;
  202. if (cp == NULL || argc > cp->maxargs)
  203. return CMD_RET_USAGE;
  204. if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
  205. return CMD_RET_SUCCESS;
  206. mmc = init_mmc_device(curr_device, false);
  207. if (!mmc)
  208. return CMD_RET_FAILURE;
  209. if (!(mmc->version & MMC_VERSION_MMC)) {
  210. printf("It is not a EMMC device\n");
  211. return CMD_RET_FAILURE;
  212. }
  213. if (mmc->version < MMC_VERSION_4_41) {
  214. printf("RPMB not supported before version 4.41\n");
  215. return CMD_RET_FAILURE;
  216. }
  217. /* Switch to the RPMB partition */
  218. original_part = mmc->block_dev.hwpart;
  219. if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, MMC_PART_RPMB) !=
  220. 0)
  221. return CMD_RET_FAILURE;
  222. ret = cp->cmd(cmdtp, flag, argc, argv);
  223. /* Return to original partition */
  224. if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, original_part) !=
  225. 0)
  226. return CMD_RET_FAILURE;
  227. return ret;
  228. }
  229. #endif
  230. static int do_mmc_read(cmd_tbl_t *cmdtp, int flag,
  231. int argc, char * const argv[])
  232. {
  233. struct mmc *mmc;
  234. u32 blk, cnt, n;
  235. void *addr;
  236. if (argc != 4)
  237. return CMD_RET_USAGE;
  238. addr = (void *)simple_strtoul(argv[1], NULL, 16);
  239. blk = simple_strtoul(argv[2], NULL, 16);
  240. cnt = simple_strtoul(argv[3], NULL, 16);
  241. mmc = init_mmc_device(curr_device, false);
  242. if (!mmc)
  243. return CMD_RET_FAILURE;
  244. printf("\nMMC read: dev # %d, block # %d, count %d ... ",
  245. curr_device, blk, cnt);
  246. n = blk_dread(mmc_get_blk_desc(mmc), blk, cnt, addr);
  247. /* flush cache after read */
  248. flush_cache((ulong)addr, cnt * 512); /* FIXME */
  249. printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
  250. return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
  251. }
  252. static int do_mmc_write(cmd_tbl_t *cmdtp, int flag,
  253. int argc, char * const argv[])
  254. {
  255. struct mmc *mmc;
  256. u32 blk, cnt, n;
  257. void *addr;
  258. if (argc != 4)
  259. return CMD_RET_USAGE;
  260. addr = (void *)simple_strtoul(argv[1], NULL, 16);
  261. blk = simple_strtoul(argv[2], NULL, 16);
  262. cnt = simple_strtoul(argv[3], NULL, 16);
  263. mmc = init_mmc_device(curr_device, false);
  264. if (!mmc)
  265. return CMD_RET_FAILURE;
  266. printf("\nMMC write: dev # %d, block # %d, count %d ... ",
  267. curr_device, blk, cnt);
  268. if (mmc_getwp(mmc) == 1) {
  269. printf("Error: card is write protected!\n");
  270. return CMD_RET_FAILURE;
  271. }
  272. n = blk_dwrite(mmc_get_blk_desc(mmc), blk, cnt, addr);
  273. printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
  274. return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
  275. }
  276. static int do_mmc_erase(cmd_tbl_t *cmdtp, int flag,
  277. int argc, char * const argv[])
  278. {
  279. struct mmc *mmc;
  280. u32 blk, cnt, n;
  281. if (argc != 3)
  282. return CMD_RET_USAGE;
  283. blk = simple_strtoul(argv[1], NULL, 16);
  284. cnt = simple_strtoul(argv[2], NULL, 16);
  285. mmc = init_mmc_device(curr_device, false);
  286. if (!mmc)
  287. return CMD_RET_FAILURE;
  288. printf("\nMMC erase: dev # %d, block # %d, count %d ... ",
  289. curr_device, blk, cnt);
  290. if (mmc_getwp(mmc) == 1) {
  291. printf("Error: card is write protected!\n");
  292. return CMD_RET_FAILURE;
  293. }
  294. n = blk_derase(mmc_get_blk_desc(mmc), blk, cnt);
  295. printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR");
  296. return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
  297. }
  298. static int do_mmc_rescan(cmd_tbl_t *cmdtp, int flag,
  299. int argc, char * const argv[])
  300. {
  301. struct mmc *mmc;
  302. mmc = init_mmc_device(curr_device, true);
  303. if (!mmc)
  304. return CMD_RET_FAILURE;
  305. return CMD_RET_SUCCESS;
  306. }
  307. static int do_mmc_part(cmd_tbl_t *cmdtp, int flag,
  308. int argc, char * const argv[])
  309. {
  310. struct blk_desc *mmc_dev;
  311. struct mmc *mmc;
  312. mmc = init_mmc_device(curr_device, false);
  313. if (!mmc)
  314. return CMD_RET_FAILURE;
  315. mmc_dev = blk_get_devnum_by_type(IF_TYPE_MMC, curr_device);
  316. if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
  317. part_print(mmc_dev);
  318. return CMD_RET_SUCCESS;
  319. }
  320. puts("get mmc type error!\n");
  321. return CMD_RET_FAILURE;
  322. }
  323. static int do_mmc_dev(cmd_tbl_t *cmdtp, int flag,
  324. int argc, char * const argv[])
  325. {
  326. int dev, part = 0, ret;
  327. struct mmc *mmc;
  328. if (argc == 1) {
  329. dev = curr_device;
  330. } else if (argc == 2) {
  331. dev = simple_strtoul(argv[1], NULL, 10);
  332. } else if (argc == 3) {
  333. dev = (int)simple_strtoul(argv[1], NULL, 10);
  334. part = (int)simple_strtoul(argv[2], NULL, 10);
  335. if (part > PART_ACCESS_MASK) {
  336. printf("#part_num shouldn't be larger than %d\n",
  337. PART_ACCESS_MASK);
  338. return CMD_RET_FAILURE;
  339. }
  340. } else {
  341. return CMD_RET_USAGE;
  342. }
  343. mmc = init_mmc_device(dev, true);
  344. if (!mmc)
  345. return CMD_RET_FAILURE;
  346. ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
  347. printf("switch to partitions #%d, %s\n",
  348. part, (!ret) ? "OK" : "ERROR");
  349. if (ret)
  350. return 1;
  351. curr_device = dev;
  352. if (mmc->part_config == MMCPART_NOAVAILABLE)
  353. printf("mmc%d is current device\n", curr_device);
  354. else
  355. printf("mmc%d(part %d) is current device\n",
  356. curr_device, mmc_get_blk_desc(mmc)->hwpart);
  357. return CMD_RET_SUCCESS;
  358. }
  359. static int do_mmc_list(cmd_tbl_t *cmdtp, int flag,
  360. int argc, char * const argv[])
  361. {
  362. print_mmc_devices('\n');
  363. return CMD_RET_SUCCESS;
  364. }
  365. static int parse_hwpart_user(struct mmc_hwpart_conf *pconf,
  366. int argc, char * const argv[])
  367. {
  368. int i = 0;
  369. memset(&pconf->user, 0, sizeof(pconf->user));
  370. while (i < argc) {
  371. if (!strcmp(argv[i], "enh")) {
  372. if (i + 2 >= argc)
  373. return -1;
  374. pconf->user.enh_start =
  375. simple_strtoul(argv[i+1], NULL, 10);
  376. pconf->user.enh_size =
  377. simple_strtoul(argv[i+2], NULL, 10);
  378. i += 3;
  379. } else if (!strcmp(argv[i], "wrrel")) {
  380. if (i + 1 >= argc)
  381. return -1;
  382. pconf->user.wr_rel_change = 1;
  383. if (!strcmp(argv[i+1], "on"))
  384. pconf->user.wr_rel_set = 1;
  385. else if (!strcmp(argv[i+1], "off"))
  386. pconf->user.wr_rel_set = 0;
  387. else
  388. return -1;
  389. i += 2;
  390. } else {
  391. break;
  392. }
  393. }
  394. return i;
  395. }
  396. static int parse_hwpart_gp(struct mmc_hwpart_conf *pconf, int pidx,
  397. int argc, char * const argv[])
  398. {
  399. int i;
  400. memset(&pconf->gp_part[pidx], 0, sizeof(pconf->gp_part[pidx]));
  401. if (1 >= argc)
  402. return -1;
  403. pconf->gp_part[pidx].size = simple_strtoul(argv[0], NULL, 10);
  404. i = 1;
  405. while (i < argc) {
  406. if (!strcmp(argv[i], "enh")) {
  407. pconf->gp_part[pidx].enhanced = 1;
  408. i += 1;
  409. } else if (!strcmp(argv[i], "wrrel")) {
  410. if (i + 1 >= argc)
  411. return -1;
  412. pconf->gp_part[pidx].wr_rel_change = 1;
  413. if (!strcmp(argv[i+1], "on"))
  414. pconf->gp_part[pidx].wr_rel_set = 1;
  415. else if (!strcmp(argv[i+1], "off"))
  416. pconf->gp_part[pidx].wr_rel_set = 0;
  417. else
  418. return -1;
  419. i += 2;
  420. } else {
  421. break;
  422. }
  423. }
  424. return i;
  425. }
  426. static int do_mmc_hwpartition(cmd_tbl_t *cmdtp, int flag,
  427. int argc, char * const argv[])
  428. {
  429. struct mmc *mmc;
  430. struct mmc_hwpart_conf pconf = { };
  431. enum mmc_hwpart_conf_mode mode = MMC_HWPART_CONF_CHECK;
  432. int i, r, pidx;
  433. mmc = init_mmc_device(curr_device, false);
  434. if (!mmc)
  435. return CMD_RET_FAILURE;
  436. if (argc < 1)
  437. return CMD_RET_USAGE;
  438. i = 1;
  439. while (i < argc) {
  440. if (!strcmp(argv[i], "user")) {
  441. i++;
  442. r = parse_hwpart_user(&pconf, argc-i, &argv[i]);
  443. if (r < 0)
  444. return CMD_RET_USAGE;
  445. i += r;
  446. } else if (!strncmp(argv[i], "gp", 2) &&
  447. strlen(argv[i]) == 3 &&
  448. argv[i][2] >= '1' && argv[i][2] <= '4') {
  449. pidx = argv[i][2] - '1';
  450. i++;
  451. r = parse_hwpart_gp(&pconf, pidx, argc-i, &argv[i]);
  452. if (r < 0)
  453. return CMD_RET_USAGE;
  454. i += r;
  455. } else if (!strcmp(argv[i], "check")) {
  456. mode = MMC_HWPART_CONF_CHECK;
  457. i++;
  458. } else if (!strcmp(argv[i], "set")) {
  459. mode = MMC_HWPART_CONF_SET;
  460. i++;
  461. } else if (!strcmp(argv[i], "complete")) {
  462. mode = MMC_HWPART_CONF_COMPLETE;
  463. i++;
  464. } else {
  465. return CMD_RET_USAGE;
  466. }
  467. }
  468. puts("Partition configuration:\n");
  469. if (pconf.user.enh_size) {
  470. puts("\tUser Enhanced Start: ");
  471. print_size(((u64)pconf.user.enh_start) << 9, "\n");
  472. puts("\tUser Enhanced Size: ");
  473. print_size(((u64)pconf.user.enh_size) << 9, "\n");
  474. } else {
  475. puts("\tNo enhanced user data area\n");
  476. }
  477. if (pconf.user.wr_rel_change)
  478. printf("\tUser partition write reliability: %s\n",
  479. pconf.user.wr_rel_set ? "on" : "off");
  480. for (pidx = 0; pidx < 4; pidx++) {
  481. if (pconf.gp_part[pidx].size) {
  482. printf("\tGP%i Capacity: ", pidx+1);
  483. print_size(((u64)pconf.gp_part[pidx].size) << 9,
  484. pconf.gp_part[pidx].enhanced ?
  485. " ENH\n" : "\n");
  486. } else {
  487. printf("\tNo GP%i partition\n", pidx+1);
  488. }
  489. if (pconf.gp_part[pidx].wr_rel_change)
  490. printf("\tGP%i write reliability: %s\n", pidx+1,
  491. pconf.gp_part[pidx].wr_rel_set ? "on" : "off");
  492. }
  493. if (!mmc_hwpart_config(mmc, &pconf, mode)) {
  494. if (mode == MMC_HWPART_CONF_COMPLETE)
  495. puts("Partitioning successful, "
  496. "power-cycle to make effective\n");
  497. return CMD_RET_SUCCESS;
  498. } else {
  499. puts("Failed!\n");
  500. return CMD_RET_FAILURE;
  501. }
  502. }
  503. #ifdef CONFIG_SUPPORT_EMMC_BOOT
  504. static int do_mmc_bootbus(cmd_tbl_t *cmdtp, int flag,
  505. int argc, char * const argv[])
  506. {
  507. int dev;
  508. struct mmc *mmc;
  509. u8 width, reset, mode;
  510. if (argc != 5)
  511. return CMD_RET_USAGE;
  512. dev = simple_strtoul(argv[1], NULL, 10);
  513. width = simple_strtoul(argv[2], NULL, 10);
  514. reset = simple_strtoul(argv[3], NULL, 10);
  515. mode = simple_strtoul(argv[4], NULL, 10);
  516. mmc = init_mmc_device(dev, false);
  517. if (!mmc)
  518. return CMD_RET_FAILURE;
  519. if (IS_SD(mmc)) {
  520. puts("BOOT_BUS_WIDTH only exists on eMMC\n");
  521. return CMD_RET_FAILURE;
  522. }
  523. /* acknowledge to be sent during boot operation */
  524. return mmc_set_boot_bus_width(mmc, width, reset, mode);
  525. }
  526. static int do_mmc_boot_resize(cmd_tbl_t *cmdtp, int flag,
  527. int argc, char * const argv[])
  528. {
  529. int dev;
  530. struct mmc *mmc;
  531. u32 bootsize, rpmbsize;
  532. if (argc != 4)
  533. return CMD_RET_USAGE;
  534. dev = simple_strtoul(argv[1], NULL, 10);
  535. bootsize = simple_strtoul(argv[2], NULL, 10);
  536. rpmbsize = simple_strtoul(argv[3], NULL, 10);
  537. mmc = init_mmc_device(dev, false);
  538. if (!mmc)
  539. return CMD_RET_FAILURE;
  540. if (IS_SD(mmc)) {
  541. printf("It is not a EMMC device\n");
  542. return CMD_RET_FAILURE;
  543. }
  544. if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) {
  545. printf("EMMC boot partition Size change Failed.\n");
  546. return CMD_RET_FAILURE;
  547. }
  548. printf("EMMC boot partition Size %d MB\n", bootsize);
  549. printf("EMMC RPMB partition Size %d MB\n", rpmbsize);
  550. return CMD_RET_SUCCESS;
  551. }
  552. static int do_mmc_partconf(cmd_tbl_t *cmdtp, int flag,
  553. int argc, char * const argv[])
  554. {
  555. int dev;
  556. struct mmc *mmc;
  557. u8 ack, part_num, access;
  558. if (argc != 5)
  559. return CMD_RET_USAGE;
  560. dev = simple_strtoul(argv[1], NULL, 10);
  561. ack = simple_strtoul(argv[2], NULL, 10);
  562. part_num = simple_strtoul(argv[3], NULL, 10);
  563. access = simple_strtoul(argv[4], NULL, 10);
  564. mmc = init_mmc_device(dev, false);
  565. if (!mmc)
  566. return CMD_RET_FAILURE;
  567. if (IS_SD(mmc)) {
  568. puts("PARTITION_CONFIG only exists on eMMC\n");
  569. return CMD_RET_FAILURE;
  570. }
  571. /* acknowledge to be sent during boot operation */
  572. return mmc_set_part_conf(mmc, ack, part_num, access);
  573. }
  574. static int do_mmc_rst_func(cmd_tbl_t *cmdtp, int flag,
  575. int argc, char * const argv[])
  576. {
  577. int dev;
  578. struct mmc *mmc;
  579. u8 enable;
  580. /*
  581. * Set the RST_n_ENABLE bit of RST_n_FUNCTION
  582. * The only valid values are 0x0, 0x1 and 0x2 and writing
  583. * a value of 0x1 or 0x2 sets the value permanently.
  584. */
  585. if (argc != 3)
  586. return CMD_RET_USAGE;
  587. dev = simple_strtoul(argv[1], NULL, 10);
  588. enable = simple_strtoul(argv[2], NULL, 10);
  589. if (enable > 2) {
  590. puts("Invalid RST_n_ENABLE value\n");
  591. return CMD_RET_USAGE;
  592. }
  593. mmc = init_mmc_device(dev, false);
  594. if (!mmc)
  595. return CMD_RET_FAILURE;
  596. if (IS_SD(mmc)) {
  597. puts("RST_n_FUNCTION only exists on eMMC\n");
  598. return CMD_RET_FAILURE;
  599. }
  600. return mmc_set_rst_n_function(mmc, enable);
  601. }
  602. #endif
  603. static int do_mmc_setdsr(cmd_tbl_t *cmdtp, int flag,
  604. int argc, char * const argv[])
  605. {
  606. struct mmc *mmc;
  607. u32 val;
  608. int ret;
  609. if (argc != 2)
  610. return CMD_RET_USAGE;
  611. val = simple_strtoul(argv[2], NULL, 16);
  612. mmc = find_mmc_device(curr_device);
  613. if (!mmc) {
  614. printf("no mmc device at slot %x\n", curr_device);
  615. return CMD_RET_FAILURE;
  616. }
  617. ret = mmc_set_dsr(mmc, val);
  618. printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR");
  619. if (!ret) {
  620. mmc->has_init = 0;
  621. if (mmc_init(mmc))
  622. return CMD_RET_FAILURE;
  623. else
  624. return CMD_RET_SUCCESS;
  625. }
  626. return ret;
  627. }
  628. static cmd_tbl_t cmd_mmc[] = {
  629. U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
  630. U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
  631. U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""),
  632. U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""),
  633. U_BOOT_CMD_MKENT(rescan, 1, 1, do_mmc_rescan, "", ""),
  634. U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""),
  635. U_BOOT_CMD_MKENT(dev, 3, 0, do_mmc_dev, "", ""),
  636. U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""),
  637. U_BOOT_CMD_MKENT(hwpartition, 28, 0, do_mmc_hwpartition, "", ""),
  638. #ifdef CONFIG_SUPPORT_EMMC_BOOT
  639. U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""),
  640. U_BOOT_CMD_MKENT(bootpart-resize, 4, 0, do_mmc_boot_resize, "", ""),
  641. U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""),
  642. U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""),
  643. #endif
  644. #ifdef CONFIG_SUPPORT_EMMC_RPMB
  645. U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""),
  646. #endif
  647. U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""),
  648. };
  649. static int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  650. {
  651. cmd_tbl_t *cp;
  652. cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
  653. /* Drop the mmc command */
  654. argc--;
  655. argv++;
  656. if (cp == NULL || argc > cp->maxargs)
  657. return CMD_RET_USAGE;
  658. if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
  659. return CMD_RET_SUCCESS;
  660. if (curr_device < 0) {
  661. if (get_mmc_num() > 0) {
  662. curr_device = 0;
  663. } else {
  664. puts("No MMC device available\n");
  665. return CMD_RET_FAILURE;
  666. }
  667. }
  668. return cp->cmd(cmdtp, flag, argc, argv);
  669. }
  670. U_BOOT_CMD(
  671. mmc, 29, 1, do_mmcops,
  672. "MMC sub system",
  673. "info - display info of the current MMC device\n"
  674. "mmc read addr blk# cnt\n"
  675. "mmc write addr blk# cnt\n"
  676. "mmc erase blk# cnt\n"
  677. "mmc rescan\n"
  678. "mmc part - lists available partition on current mmc device\n"
  679. "mmc dev [dev] [part] - show or set current mmc device [partition]\n"
  680. "mmc list - lists available devices\n"
  681. "mmc hwpartition [args...] - does hardware partitioning\n"
  682. " arguments (sizes in 512-byte blocks):\n"
  683. " [user [enh start cnt] [wrrel {on|off}]] - sets user data area attributes\n"
  684. " [gp1|gp2|gp3|gp4 cnt [enh] [wrrel {on|off}]] - general purpose partition\n"
  685. " [check|set|complete] - mode, complete set partitioning completed\n"
  686. " WARNING: Partitioning is a write-once setting once it is set to complete.\n"
  687. " Power cycling is required to initialize partitions after set to complete.\n"
  688. #ifdef CONFIG_SUPPORT_EMMC_BOOT
  689. "mmc bootbus dev boot_bus_width reset_boot_bus_width boot_mode\n"
  690. " - Set the BOOT_BUS_WIDTH field of the specified device\n"
  691. "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n"
  692. " - Change sizes of boot and RPMB partitions of specified device\n"
  693. "mmc partconf dev boot_ack boot_partition partition_access\n"
  694. " - Change the bits of the PARTITION_CONFIG field of the specified device\n"
  695. "mmc rst-function dev value\n"
  696. " - Change the RST_n_FUNCTION field of the specified device\n"
  697. " WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n"
  698. #endif
  699. #ifdef CONFIG_SUPPORT_EMMC_RPMB
  700. "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n"
  701. "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n"
  702. "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n"
  703. "mmc rpmb counter - read the value of the write counter\n"
  704. #endif
  705. "mmc setdsr <value> - set DSR register value\n"
  706. );
  707. /* Old command kept for compatibility. Same as 'mmc info' */
  708. U_BOOT_CMD(
  709. mmcinfo, 1, 0, do_mmcinfo,
  710. "display MMC info",
  711. "- display info of the current MMC device"
  712. );