3 * Kyle Harris, kharris@nexus-tech.net
5 * SPDX-License-Identifier: GPL-2.0+
12 static int curr_device = -1;
13 #ifndef CONFIG_GENERIC_MMC
14 int do_mmc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
21 if (strcmp(argv[1], "init") == 0) {
27 } else if (argc == 3) {
28 dev = (int)simple_strtoul(argv[2], NULL, 10);
33 if (mmc_legacy_init(dev) != 0) {
34 puts("No MMC card found\n");
39 printf("mmc%d is available\n", curr_device);
40 } else if (strcmp(argv[1], "device") == 0) {
42 if (curr_device < 0) {
43 puts("No MMC device available\n");
46 } else if (argc == 3) {
47 dev = (int)simple_strtoul(argv[2], NULL, 10);
49 #ifdef CONFIG_SYS_MMC_SET_DEV
50 if (mmc_set_dev(dev) != 0)
58 printf("mmc%d is current device\n", curr_device);
69 "init [dev] - init MMC sub system\n"
70 "mmc device [dev] - show or set current device"
72 #else /* !CONFIG_GENERIC_MMC */
74 static void print_mmcinfo(struct mmc *mmc)
78 printf("Device: %s\n", mmc->cfg->name);
79 printf("Manufacturer ID: %x\n", mmc->cid[0] >> 24);
80 printf("OEM: %x\n", (mmc->cid[0] >> 8) & 0xffff);
81 printf("Name: %c%c%c%c%c \n", mmc->cid[0] & 0xff,
82 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
83 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
85 printf("Tran Speed: %d\n", mmc->tran_speed);
86 printf("Rd Block Len: %d\n", mmc->read_bl_len);
88 printf("%s version %d.%d\n", IS_SD(mmc) ? "SD" : "MMC",
89 (mmc->version >> 8) & 0xf, mmc->version & 0xff);
91 printf("High Capacity: %s\n", mmc->high_capacity ? "Yes" : "No");
93 print_size(mmc->capacity, "\n");
95 printf("Bus Width: %d-bit%s\n", mmc->bus_width,
96 mmc->ddr_mode ? " DDR" : "");
98 if (!IS_SD(mmc) && mmc->version >= MMC_VERSION_4) {
99 puts("User Capacity: ");
100 print_size(mmc->capacity_user, "\n");
101 puts("Boot Capacity: ");
102 print_size(mmc->capacity_boot, "\n");
103 puts("RPMB Capacity: ");
104 print_size(mmc->capacity_rpmb, "\n");
105 for (i = 0; i < ARRAY_SIZE(mmc->capacity_gp); i++) {
106 if (mmc->capacity_gp[i]) {
107 printf("GP%i Capacity: ", i);
108 print_size(mmc->capacity_gp[i], "\n");
113 static struct mmc *init_mmc_device(int dev, bool force_init)
116 mmc = find_mmc_device(dev);
118 printf("no mmc device at slot %x\n", dev);
127 static int do_mmcinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
131 if (curr_device < 0) {
132 if (get_mmc_num() > 0)
135 puts("No MMC device available\n");
140 mmc = init_mmc_device(curr_device, false);
142 return CMD_RET_FAILURE;
145 return CMD_RET_SUCCESS;
148 #ifdef CONFIG_SUPPORT_EMMC_RPMB
149 static int confirm_key_prog(void)
151 puts("Warning: Programming authentication key can be done only once !\n"
152 " Use this command only if you are sure of what you are doing,\n"
153 "Really perform the key programming? <y/N> ");
157 puts("Authentication key programming aborted\n");
160 static int do_mmcrpmb_key(cmd_tbl_t *cmdtp, int flag,
161 int argc, char * const argv[])
164 struct mmc *mmc = find_mmc_device(curr_device);
167 return CMD_RET_USAGE;
169 key_addr = (void *)simple_strtoul(argv[1], NULL, 16);
170 if (!confirm_key_prog())
171 return CMD_RET_FAILURE;
172 if (mmc_rpmb_set_key(mmc, key_addr)) {
173 printf("ERROR - Key already programmed ?\n");
174 return CMD_RET_FAILURE;
176 return CMD_RET_SUCCESS;
178 static int do_mmcrpmb_read(cmd_tbl_t *cmdtp, int flag,
179 int argc, char * const argv[])
184 void *key_addr = NULL;
185 struct mmc *mmc = find_mmc_device(curr_device);
188 return CMD_RET_USAGE;
190 addr = (void *)simple_strtoul(argv[1], NULL, 16);
191 blk = simple_strtoul(argv[2], NULL, 16);
192 cnt = simple_strtoul(argv[3], NULL, 16);
195 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);
201 printf("%d RPMB blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
203 return CMD_RET_FAILURE;
204 return CMD_RET_SUCCESS;
206 static int do_mmcrpmb_write(cmd_tbl_t *cmdtp, int flag,
207 int argc, char * const argv[])
213 struct mmc *mmc = find_mmc_device(curr_device);
216 return CMD_RET_USAGE;
218 addr = (void *)simple_strtoul(argv[1], NULL, 16);
219 blk = simple_strtoul(argv[2], NULL, 16);
220 cnt = simple_strtoul(argv[3], NULL, 16);
221 key_addr = (void *)simple_strtoul(argv[4], NULL, 16);
223 printf("\nMMC RPMB write: dev # %d, block # %d, count %d ... ",
224 curr_device, blk, cnt);
225 n = mmc_rpmb_write(mmc, addr, blk, cnt, key_addr);
227 printf("%d RPMB blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
229 return CMD_RET_FAILURE;
230 return CMD_RET_SUCCESS;
232 static int do_mmcrpmb_counter(cmd_tbl_t *cmdtp, int flag,
233 int argc, char * const argv[])
235 unsigned long counter;
236 struct mmc *mmc = find_mmc_device(curr_device);
238 if (mmc_rpmb_get_counter(mmc, &counter))
239 return CMD_RET_FAILURE;
240 printf("RPMB Write counter= %lx\n", counter);
241 return CMD_RET_SUCCESS;
244 static cmd_tbl_t cmd_rpmb[] = {
245 U_BOOT_CMD_MKENT(key, 2, 0, do_mmcrpmb_key, "", ""),
246 U_BOOT_CMD_MKENT(read, 5, 1, do_mmcrpmb_read, "", ""),
247 U_BOOT_CMD_MKENT(write, 5, 0, do_mmcrpmb_write, "", ""),
248 U_BOOT_CMD_MKENT(counter, 1, 1, do_mmcrpmb_counter, "", ""),
251 static int do_mmcrpmb(cmd_tbl_t *cmdtp, int flag,
252 int argc, char * const argv[])
259 cp = find_cmd_tbl(argv[1], cmd_rpmb, ARRAY_SIZE(cmd_rpmb));
261 /* Drop the rpmb subcommand */
265 if (cp == NULL || argc > cp->maxargs)
266 return CMD_RET_USAGE;
267 if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
268 return CMD_RET_SUCCESS;
270 mmc = init_mmc_device(curr_device, false);
272 return CMD_RET_FAILURE;
274 if (!(mmc->version & MMC_VERSION_MMC)) {
275 printf("It is not a EMMC device\n");
276 return CMD_RET_FAILURE;
278 if (mmc->version < MMC_VERSION_4_41) {
279 printf("RPMB not supported before version 4.41\n");
280 return CMD_RET_FAILURE;
282 /* Switch to the RPMB partition */
283 original_part = mmc->part_num;
284 if (mmc->part_num != MMC_PART_RPMB) {
285 if (mmc_switch_part(curr_device, MMC_PART_RPMB) != 0)
286 return CMD_RET_FAILURE;
287 mmc->part_num = MMC_PART_RPMB;
289 ret = cp->cmd(cmdtp, flag, argc, argv);
291 /* Return to original partition */
292 if (mmc->part_num != original_part) {
293 if (mmc_switch_part(curr_device, original_part) != 0)
294 return CMD_RET_FAILURE;
295 mmc->part_num = original_part;
301 static int do_mmc_read(cmd_tbl_t *cmdtp, int flag,
302 int argc, char * const argv[])
309 return CMD_RET_USAGE;
311 addr = (void *)simple_strtoul(argv[1], NULL, 16);
312 blk = simple_strtoul(argv[2], NULL, 16);
313 cnt = simple_strtoul(argv[3], NULL, 16);
315 mmc = init_mmc_device(curr_device, false);
317 return CMD_RET_FAILURE;
319 printf("\nMMC read: dev # %d, block # %d, count %d ... ",
320 curr_device, blk, cnt);
322 n = mmc->block_dev.block_read(curr_device, blk, cnt, addr);
323 /* flush cache after read */
324 flush_cache((ulong)addr, cnt * 512); /* FIXME */
325 printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
327 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
329 static int do_mmc_write(cmd_tbl_t *cmdtp, int flag,
330 int argc, char * const argv[])
337 return CMD_RET_USAGE;
339 addr = (void *)simple_strtoul(argv[1], NULL, 16);
340 blk = simple_strtoul(argv[2], NULL, 16);
341 cnt = simple_strtoul(argv[3], NULL, 16);
343 mmc = init_mmc_device(curr_device, false);
345 return CMD_RET_FAILURE;
347 printf("\nMMC write: dev # %d, block # %d, count %d ... ",
348 curr_device, blk, cnt);
350 if (mmc_getwp(mmc) == 1) {
351 printf("Error: card is write protected!\n");
352 return CMD_RET_FAILURE;
354 n = mmc->block_dev.block_write(curr_device, blk, cnt, addr);
355 printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
357 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
359 static int do_mmc_erase(cmd_tbl_t *cmdtp, int flag,
360 int argc, char * const argv[])
366 return CMD_RET_USAGE;
368 blk = simple_strtoul(argv[1], NULL, 16);
369 cnt = simple_strtoul(argv[2], NULL, 16);
371 mmc = init_mmc_device(curr_device, false);
373 return CMD_RET_FAILURE;
375 printf("\nMMC erase: dev # %d, block # %d, count %d ... ",
376 curr_device, blk, cnt);
378 if (mmc_getwp(mmc) == 1) {
379 printf("Error: card is write protected!\n");
380 return CMD_RET_FAILURE;
382 n = mmc->block_dev.block_erase(curr_device, blk, cnt);
383 printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR");
385 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
387 static int do_mmc_rescan(cmd_tbl_t *cmdtp, int flag,
388 int argc, char * const argv[])
392 mmc = init_mmc_device(curr_device, true);
394 return CMD_RET_FAILURE;
396 return CMD_RET_SUCCESS;
398 static int do_mmc_part(cmd_tbl_t *cmdtp, int flag,
399 int argc, char * const argv[])
401 block_dev_desc_t *mmc_dev;
404 mmc = init_mmc_device(curr_device, false);
406 return CMD_RET_FAILURE;
408 mmc_dev = mmc_get_dev(curr_device);
409 if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
411 return CMD_RET_SUCCESS;
414 puts("get mmc type error!\n");
415 return CMD_RET_FAILURE;
417 static int do_mmc_dev(cmd_tbl_t *cmdtp, int flag,
418 int argc, char * const argv[])
420 int dev, part = 0, ret;
425 } else if (argc == 2) {
426 dev = simple_strtoul(argv[1], NULL, 10);
427 } else if (argc == 3) {
428 dev = (int)simple_strtoul(argv[1], NULL, 10);
429 part = (int)simple_strtoul(argv[2], NULL, 10);
430 if (part > PART_ACCESS_MASK) {
431 printf("#part_num shouldn't be larger than %d\n",
433 return CMD_RET_FAILURE;
436 return CMD_RET_USAGE;
439 mmc = init_mmc_device(dev, true);
441 return CMD_RET_FAILURE;
443 ret = mmc_select_hwpart(dev, part);
444 printf("switch to partitions #%d, %s\n",
445 part, (!ret) ? "OK" : "ERROR");
450 if (mmc->part_config == MMCPART_NOAVAILABLE)
451 printf("mmc%d is current device\n", curr_device);
453 printf("mmc%d(part %d) is current device\n",
454 curr_device, mmc->part_num);
456 return CMD_RET_SUCCESS;
458 static int do_mmc_list(cmd_tbl_t *cmdtp, int flag,
459 int argc, char * const argv[])
461 print_mmc_devices('\n');
462 return CMD_RET_SUCCESS;
464 #ifdef CONFIG_SUPPORT_EMMC_BOOT
465 static int do_mmc_bootbus(cmd_tbl_t *cmdtp, int flag,
466 int argc, char * const argv[])
470 u8 width, reset, mode;
473 return CMD_RET_USAGE;
474 dev = simple_strtoul(argv[1], NULL, 10);
475 width = simple_strtoul(argv[2], NULL, 10);
476 reset = simple_strtoul(argv[3], NULL, 10);
477 mode = simple_strtoul(argv[4], NULL, 10);
479 mmc = init_mmc_device(dev, false);
481 return CMD_RET_FAILURE;
484 puts("BOOT_BUS_WIDTH only exists on eMMC\n");
485 return CMD_RET_FAILURE;
488 /* acknowledge to be sent during boot operation */
489 return mmc_set_boot_bus_width(mmc, width, reset, mode);
491 static int do_mmc_boot_resize(cmd_tbl_t *cmdtp, int flag,
492 int argc, char * const argv[])
496 u32 bootsize, rpmbsize;
499 return CMD_RET_USAGE;
500 dev = simple_strtoul(argv[1], NULL, 10);
501 bootsize = simple_strtoul(argv[2], NULL, 10);
502 rpmbsize = simple_strtoul(argv[3], NULL, 10);
504 mmc = init_mmc_device(dev, false);
506 return CMD_RET_FAILURE;
509 printf("It is not a EMMC device\n");
510 return CMD_RET_FAILURE;
513 if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) {
514 printf("EMMC boot partition Size change Failed.\n");
515 return CMD_RET_FAILURE;
518 printf("EMMC boot partition Size %d MB\n", bootsize);
519 printf("EMMC RPMB partition Size %d MB\n", rpmbsize);
520 return CMD_RET_SUCCESS;
522 static int do_mmc_partconf(cmd_tbl_t *cmdtp, int flag,
523 int argc, char * const argv[])
527 u8 ack, part_num, access;
530 return CMD_RET_USAGE;
532 dev = simple_strtoul(argv[1], NULL, 10);
533 ack = simple_strtoul(argv[2], NULL, 10);
534 part_num = simple_strtoul(argv[3], NULL, 10);
535 access = simple_strtoul(argv[4], NULL, 10);
537 mmc = init_mmc_device(dev, false);
539 return CMD_RET_FAILURE;
542 puts("PARTITION_CONFIG only exists on eMMC\n");
543 return CMD_RET_FAILURE;
546 /* acknowledge to be sent during boot operation */
547 return mmc_set_part_conf(mmc, ack, part_num, access);
549 static int do_mmc_rst_func(cmd_tbl_t *cmdtp, int flag,
550 int argc, char * const argv[])
557 * Set the RST_n_ENABLE bit of RST_n_FUNCTION
558 * The only valid values are 0x0, 0x1 and 0x2 and writing
559 * a value of 0x1 or 0x2 sets the value permanently.
562 return CMD_RET_USAGE;
564 dev = simple_strtoul(argv[1], NULL, 10);
565 enable = simple_strtoul(argv[2], NULL, 10);
567 if (enable > 2 || enable < 0) {
568 puts("Invalid RST_n_ENABLE value\n");
569 return CMD_RET_USAGE;
572 mmc = init_mmc_device(dev, false);
574 return CMD_RET_FAILURE;
577 puts("RST_n_FUNCTION only exists on eMMC\n");
578 return CMD_RET_FAILURE;
581 return mmc_set_rst_n_function(mmc, enable);
584 static int do_mmc_setdsr(cmd_tbl_t *cmdtp, int flag,
585 int argc, char * const argv[])
592 return CMD_RET_USAGE;
593 val = simple_strtoul(argv[2], NULL, 16);
595 mmc = find_mmc_device(curr_device);
597 printf("no mmc device at slot %x\n", curr_device);
598 return CMD_RET_FAILURE;
600 ret = mmc_set_dsr(mmc, val);
601 printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR");
605 return CMD_RET_FAILURE;
607 return CMD_RET_SUCCESS;
612 static cmd_tbl_t cmd_mmc[] = {
613 U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
614 U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
615 U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""),
616 U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""),
617 U_BOOT_CMD_MKENT(rescan, 1, 1, do_mmc_rescan, "", ""),
618 U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""),
619 U_BOOT_CMD_MKENT(dev, 3, 0, do_mmc_dev, "", ""),
620 U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""),
621 #ifdef CONFIG_SUPPORT_EMMC_BOOT
622 U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""),
623 U_BOOT_CMD_MKENT(bootpart-resize, 4, 0, do_mmc_boot_resize, "", ""),
624 U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""),
625 U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""),
627 #ifdef CONFIG_SUPPORT_EMMC_RPMB
628 U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""),
630 U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""),
633 static int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
637 cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
639 /* Drop the mmc command */
643 if (cp == NULL || argc > cp->maxargs)
644 return CMD_RET_USAGE;
645 if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
646 return CMD_RET_SUCCESS;
648 if (curr_device < 0) {
649 if (get_mmc_num() > 0) {
652 puts("No MMC device available\n");
653 return CMD_RET_FAILURE;
656 return cp->cmd(cmdtp, flag, argc, argv);
660 mmc, 7, 1, do_mmcops,
662 "info - display info of the current MMC device\n"
663 "mmc read addr blk# cnt\n"
664 "mmc write addr blk# cnt\n"
665 "mmc erase blk# cnt\n"
667 "mmc part - lists available partition on current mmc device\n"
668 "mmc dev [dev] [part] - show or set current mmc device [partition]\n"
669 "mmc list - lists available devices\n"
670 #ifdef CONFIG_SUPPORT_EMMC_BOOT
671 "mmc bootbus dev boot_bus_width reset_boot_bus_width boot_mode\n"
672 " - Set the BOOT_BUS_WIDTH field of the specified device\n"
673 "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n"
674 " - Change sizes of boot and RPMB partitions of specified device\n"
675 "mmc partconf dev boot_ack boot_partition partition_access\n"
676 " - Change the bits of the PARTITION_CONFIG field of the specified device\n"
677 "mmc rst-function dev value\n"
678 " - Change the RST_n_FUNCTION field of the specified device\n"
679 " WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n"
681 #ifdef CONFIG_SUPPORT_EMMC_RPMB
682 "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n"
683 "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n"
684 "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n"
685 "mmc rpmb counter - read the value of the write counter\n"
687 "mmc setdsr <value> - set DSR register value\n"
690 /* Old command kept for compatibility. Same as 'mmc info' */
692 mmcinfo, 1, 0, do_mmcinfo,
694 "- display info of the current MMC device"
697 #endif /* !CONFIG_GENERIC_MMC */