cmd_mmc.c 23 KB

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