183d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+ 22e192b24SSimon Glass /* 32e192b24SSimon Glass * (C) Copyright 2003 42e192b24SSimon Glass * Kyle Harris, kharris@nexus-tech.net 52e192b24SSimon Glass */ 62e192b24SSimon Glass 72e192b24SSimon Glass #include <common.h> 82e192b24SSimon Glass #include <command.h> 92e192b24SSimon Glass #include <console.h> 102e192b24SSimon Glass #include <mmc.h> 11732bc7ceSJassi Brar #include <sparse_format.h> 12732bc7ceSJassi Brar #include <image-sparse.h> 132e192b24SSimon Glass 142e192b24SSimon Glass static int curr_device = -1; 152e192b24SSimon Glass 162e192b24SSimon Glass static void print_mmcinfo(struct mmc *mmc) 172e192b24SSimon Glass { 182e192b24SSimon Glass int i; 192e192b24SSimon Glass 202e192b24SSimon Glass printf("Device: %s\n", mmc->cfg->name); 212e192b24SSimon Glass printf("Manufacturer ID: %x\n", mmc->cid[0] >> 24); 222e192b24SSimon Glass printf("OEM: %x\n", (mmc->cid[0] >> 8) & 0xffff); 232e192b24SSimon Glass printf("Name: %c%c%c%c%c \n", mmc->cid[0] & 0xff, 242e192b24SSimon Glass (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 252e192b24SSimon Glass (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff); 262e192b24SSimon Glass 277a96ec74SJean-Jacques Hiblot printf("Bus Speed: %d\n", mmc->clock); 2852d241dfSJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MMC_VERBOSE) 297a96ec74SJean-Jacques Hiblot printf("Mode : %s\n", mmc_mode_name(mmc->selected_mode)); 3052d241dfSJean-Jacques Hiblot mmc_dump_capabilities("card capabilities", mmc->card_caps); 3152d241dfSJean-Jacques Hiblot mmc_dump_capabilities("host capabilities", mmc->host_caps); 3252d241dfSJean-Jacques Hiblot #endif 332e192b24SSimon Glass printf("Rd Block Len: %d\n", mmc->read_bl_len); 342e192b24SSimon Glass 352e192b24SSimon Glass printf("%s version %d.%d", IS_SD(mmc) ? "SD" : "MMC", 362e192b24SSimon Glass EXTRACT_SDMMC_MAJOR_VERSION(mmc->version), 372e192b24SSimon Glass EXTRACT_SDMMC_MINOR_VERSION(mmc->version)); 382e192b24SSimon Glass if (EXTRACT_SDMMC_CHANGE_VERSION(mmc->version) != 0) 392e192b24SSimon Glass printf(".%d", EXTRACT_SDMMC_CHANGE_VERSION(mmc->version)); 402e192b24SSimon Glass printf("\n"); 412e192b24SSimon Glass 422e192b24SSimon Glass printf("High Capacity: %s\n", mmc->high_capacity ? "Yes" : "No"); 432e192b24SSimon Glass puts("Capacity: "); 442e192b24SSimon Glass print_size(mmc->capacity, "\n"); 452e192b24SSimon Glass 462e192b24SSimon Glass printf("Bus Width: %d-bit%s\n", mmc->bus_width, 472e192b24SSimon Glass mmc->ddr_mode ? " DDR" : ""); 482e192b24SSimon Glass 49e6fa5a54SJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MMC_WRITE) 502e192b24SSimon Glass puts("Erase Group Size: "); 512e192b24SSimon Glass print_size(((u64)mmc->erase_grp_size) << 9, "\n"); 52e6fa5a54SJean-Jacques Hiblot #endif 532e192b24SSimon Glass 542e192b24SSimon Glass if (!IS_SD(mmc) && mmc->version >= MMC_VERSION_4_41) { 552e192b24SSimon Glass bool has_enh = (mmc->part_support & ENHNCD_SUPPORT) != 0; 562e192b24SSimon Glass bool usr_enh = has_enh && (mmc->part_attr & EXT_CSD_ENH_USR); 572e192b24SSimon Glass 58b7a6e2c9SJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING) 592e192b24SSimon Glass puts("HC WP Group Size: "); 602e192b24SSimon Glass print_size(((u64)mmc->hc_wp_grp_size) << 9, "\n"); 61b7a6e2c9SJean-Jacques Hiblot #endif 622e192b24SSimon Glass 632e192b24SSimon Glass puts("User Capacity: "); 642e192b24SSimon Glass print_size(mmc->capacity_user, usr_enh ? " ENH" : ""); 652e192b24SSimon Glass if (mmc->wr_rel_set & EXT_CSD_WR_DATA_REL_USR) 662e192b24SSimon Glass puts(" WRREL\n"); 672e192b24SSimon Glass else 682e192b24SSimon Glass putc('\n'); 692e192b24SSimon Glass if (usr_enh) { 702e192b24SSimon Glass puts("User Enhanced Start: "); 712e192b24SSimon Glass print_size(mmc->enh_user_start, "\n"); 722e192b24SSimon Glass puts("User Enhanced Size: "); 732e192b24SSimon Glass print_size(mmc->enh_user_size, "\n"); 742e192b24SSimon Glass } 752e192b24SSimon Glass puts("Boot Capacity: "); 762e192b24SSimon Glass print_size(mmc->capacity_boot, has_enh ? " ENH\n" : "\n"); 772e192b24SSimon Glass puts("RPMB Capacity: "); 782e192b24SSimon Glass print_size(mmc->capacity_rpmb, has_enh ? " ENH\n" : "\n"); 792e192b24SSimon Glass 802e192b24SSimon Glass for (i = 0; i < ARRAY_SIZE(mmc->capacity_gp); i++) { 812e192b24SSimon Glass bool is_enh = has_enh && 822e192b24SSimon Glass (mmc->part_attr & EXT_CSD_ENH_GP(i)); 832e192b24SSimon Glass if (mmc->capacity_gp[i]) { 842e192b24SSimon Glass printf("GP%i Capacity: ", i+1); 852e192b24SSimon Glass print_size(mmc->capacity_gp[i], 862e192b24SSimon Glass is_enh ? " ENH" : ""); 872e192b24SSimon Glass if (mmc->wr_rel_set & EXT_CSD_WR_DATA_REL_GP(i)) 882e192b24SSimon Glass puts(" WRREL\n"); 892e192b24SSimon Glass else 902e192b24SSimon Glass putc('\n'); 912e192b24SSimon Glass } 922e192b24SSimon Glass } 932e192b24SSimon Glass } 942e192b24SSimon Glass } 952e192b24SSimon Glass static struct mmc *init_mmc_device(int dev, bool force_init) 962e192b24SSimon Glass { 972e192b24SSimon Glass struct mmc *mmc; 982e192b24SSimon Glass mmc = find_mmc_device(dev); 992e192b24SSimon Glass if (!mmc) { 1002e192b24SSimon Glass printf("no mmc device at slot %x\n", dev); 1012e192b24SSimon Glass return NULL; 1022e192b24SSimon Glass } 103bcfde7ffSEric Nelson 104d2a08369SMarek Vasut if (!mmc_getcd(mmc)) 105d2a08369SMarek Vasut force_init = true; 106d2a08369SMarek Vasut 1072e192b24SSimon Glass if (force_init) 1082e192b24SSimon Glass mmc->has_init = 0; 1092e192b24SSimon Glass if (mmc_init(mmc)) 1102e192b24SSimon Glass return NULL; 111*1d044d32SMarek Vasut 112*1d044d32SMarek Vasut #ifdef CONFIG_BLOCK_CACHE 113*1d044d32SMarek Vasut struct blk_desc *bd = mmc_get_blk_desc(mmc); 114*1d044d32SMarek Vasut blkcache_invalidate(bd->if_type, bd->devnum); 115*1d044d32SMarek Vasut #endif 116*1d044d32SMarek Vasut 1172e192b24SSimon Glass return mmc; 1182e192b24SSimon Glass } 1192e192b24SSimon Glass static int do_mmcinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 1202e192b24SSimon Glass { 1212e192b24SSimon Glass struct mmc *mmc; 1222e192b24SSimon Glass 1232e192b24SSimon Glass if (curr_device < 0) { 1242e192b24SSimon Glass if (get_mmc_num() > 0) 1252e192b24SSimon Glass curr_device = 0; 1262e192b24SSimon Glass else { 1272e192b24SSimon Glass puts("No MMC device available\n"); 1282e192b24SSimon Glass return 1; 1292e192b24SSimon Glass } 1302e192b24SSimon Glass } 1312e192b24SSimon Glass 1322e192b24SSimon Glass mmc = init_mmc_device(curr_device, false); 1332e192b24SSimon Glass if (!mmc) 1342e192b24SSimon Glass return CMD_RET_FAILURE; 1352e192b24SSimon Glass 1362e192b24SSimon Glass print_mmcinfo(mmc); 1372e192b24SSimon Glass return CMD_RET_SUCCESS; 1382e192b24SSimon Glass } 1392e192b24SSimon Glass 1405a7b11e6SAlex Kiernan #if CONFIG_IS_ENABLED(CMD_MMC_RPMB) 1412e192b24SSimon Glass static int confirm_key_prog(void) 1422e192b24SSimon Glass { 1432e192b24SSimon Glass puts("Warning: Programming authentication key can be done only once !\n" 1442e192b24SSimon Glass " Use this command only if you are sure of what you are doing,\n" 1452e192b24SSimon Glass "Really perform the key programming? <y/N> "); 1462e192b24SSimon Glass if (confirm_yesno()) 1472e192b24SSimon Glass return 1; 1482e192b24SSimon Glass 1492e192b24SSimon Glass puts("Authentication key programming aborted\n"); 1502e192b24SSimon Glass return 0; 1512e192b24SSimon Glass } 1522e192b24SSimon Glass static int do_mmcrpmb_key(cmd_tbl_t *cmdtp, int flag, 1532e192b24SSimon Glass int argc, char * const argv[]) 1542e192b24SSimon Glass { 1552e192b24SSimon Glass void *key_addr; 1562e192b24SSimon Glass struct mmc *mmc = find_mmc_device(curr_device); 1572e192b24SSimon Glass 1582e192b24SSimon Glass if (argc != 2) 1592e192b24SSimon Glass return CMD_RET_USAGE; 1602e192b24SSimon Glass 1612e192b24SSimon Glass key_addr = (void *)simple_strtoul(argv[1], NULL, 16); 1622e192b24SSimon Glass if (!confirm_key_prog()) 1632e192b24SSimon Glass return CMD_RET_FAILURE; 1642e192b24SSimon Glass if (mmc_rpmb_set_key(mmc, key_addr)) { 1652e192b24SSimon Glass printf("ERROR - Key already programmed ?\n"); 1662e192b24SSimon Glass return CMD_RET_FAILURE; 1672e192b24SSimon Glass } 1682e192b24SSimon Glass return CMD_RET_SUCCESS; 1692e192b24SSimon Glass } 1702e192b24SSimon Glass static int do_mmcrpmb_read(cmd_tbl_t *cmdtp, int flag, 1712e192b24SSimon Glass int argc, char * const argv[]) 1722e192b24SSimon Glass { 1732e192b24SSimon Glass u16 blk, cnt; 1742e192b24SSimon Glass void *addr; 1752e192b24SSimon Glass int n; 1762e192b24SSimon Glass void *key_addr = NULL; 1772e192b24SSimon Glass struct mmc *mmc = find_mmc_device(curr_device); 1782e192b24SSimon Glass 1792e192b24SSimon Glass if (argc < 4) 1802e192b24SSimon Glass return CMD_RET_USAGE; 1812e192b24SSimon Glass 1822e192b24SSimon Glass addr = (void *)simple_strtoul(argv[1], NULL, 16); 1832e192b24SSimon Glass blk = simple_strtoul(argv[2], NULL, 16); 1842e192b24SSimon Glass cnt = simple_strtoul(argv[3], NULL, 16); 1852e192b24SSimon Glass 1862e192b24SSimon Glass if (argc == 5) 1872e192b24SSimon Glass key_addr = (void *)simple_strtoul(argv[4], NULL, 16); 1882e192b24SSimon Glass 1892e192b24SSimon Glass printf("\nMMC RPMB read: dev # %d, block # %d, count %d ... ", 1902e192b24SSimon Glass curr_device, blk, cnt); 1912e192b24SSimon Glass n = mmc_rpmb_read(mmc, addr, blk, cnt, key_addr); 1922e192b24SSimon Glass 1932e192b24SSimon Glass printf("%d RPMB blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR"); 1942e192b24SSimon Glass if (n != cnt) 1952e192b24SSimon Glass return CMD_RET_FAILURE; 1962e192b24SSimon Glass return CMD_RET_SUCCESS; 1972e192b24SSimon Glass } 1982e192b24SSimon Glass static int do_mmcrpmb_write(cmd_tbl_t *cmdtp, int flag, 1992e192b24SSimon Glass int argc, char * const argv[]) 2002e192b24SSimon Glass { 2012e192b24SSimon Glass u16 blk, cnt; 2022e192b24SSimon Glass void *addr; 2032e192b24SSimon Glass int n; 2042e192b24SSimon Glass void *key_addr; 2052e192b24SSimon Glass struct mmc *mmc = find_mmc_device(curr_device); 2062e192b24SSimon Glass 2072e192b24SSimon Glass if (argc != 5) 2082e192b24SSimon Glass return CMD_RET_USAGE; 2092e192b24SSimon Glass 2102e192b24SSimon Glass addr = (void *)simple_strtoul(argv[1], NULL, 16); 2112e192b24SSimon Glass blk = simple_strtoul(argv[2], NULL, 16); 2122e192b24SSimon Glass cnt = simple_strtoul(argv[3], NULL, 16); 2132e192b24SSimon Glass key_addr = (void *)simple_strtoul(argv[4], NULL, 16); 2142e192b24SSimon Glass 2152e192b24SSimon Glass printf("\nMMC RPMB write: dev # %d, block # %d, count %d ... ", 2162e192b24SSimon Glass curr_device, blk, cnt); 2172e192b24SSimon Glass n = mmc_rpmb_write(mmc, addr, blk, cnt, key_addr); 2182e192b24SSimon Glass 2192e192b24SSimon Glass printf("%d RPMB blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR"); 2202e192b24SSimon Glass if (n != cnt) 2212e192b24SSimon Glass return CMD_RET_FAILURE; 2222e192b24SSimon Glass return CMD_RET_SUCCESS; 2232e192b24SSimon Glass } 2242e192b24SSimon Glass static int do_mmcrpmb_counter(cmd_tbl_t *cmdtp, int flag, 2252e192b24SSimon Glass int argc, char * const argv[]) 2262e192b24SSimon Glass { 2272e192b24SSimon Glass unsigned long counter; 2282e192b24SSimon Glass struct mmc *mmc = find_mmc_device(curr_device); 2292e192b24SSimon Glass 2302e192b24SSimon Glass if (mmc_rpmb_get_counter(mmc, &counter)) 2312e192b24SSimon Glass return CMD_RET_FAILURE; 2322e192b24SSimon Glass printf("RPMB Write counter= %lx\n", counter); 2332e192b24SSimon Glass return CMD_RET_SUCCESS; 2342e192b24SSimon Glass } 2352e192b24SSimon Glass 2362e192b24SSimon Glass static cmd_tbl_t cmd_rpmb[] = { 2372e192b24SSimon Glass U_BOOT_CMD_MKENT(key, 2, 0, do_mmcrpmb_key, "", ""), 2382e192b24SSimon Glass U_BOOT_CMD_MKENT(read, 5, 1, do_mmcrpmb_read, "", ""), 2392e192b24SSimon Glass U_BOOT_CMD_MKENT(write, 5, 0, do_mmcrpmb_write, "", ""), 2402e192b24SSimon Glass U_BOOT_CMD_MKENT(counter, 1, 1, do_mmcrpmb_counter, "", ""), 2412e192b24SSimon Glass }; 2422e192b24SSimon Glass 2432e192b24SSimon Glass static int do_mmcrpmb(cmd_tbl_t *cmdtp, int flag, 2442e192b24SSimon Glass int argc, char * const argv[]) 2452e192b24SSimon Glass { 2462e192b24SSimon Glass cmd_tbl_t *cp; 2472e192b24SSimon Glass struct mmc *mmc; 2482e192b24SSimon Glass char original_part; 2492e192b24SSimon Glass int ret; 2502e192b24SSimon Glass 2512e192b24SSimon Glass cp = find_cmd_tbl(argv[1], cmd_rpmb, ARRAY_SIZE(cmd_rpmb)); 2522e192b24SSimon Glass 2532e192b24SSimon Glass /* Drop the rpmb subcommand */ 2542e192b24SSimon Glass argc--; 2552e192b24SSimon Glass argv++; 2562e192b24SSimon Glass 2572e192b24SSimon Glass if (cp == NULL || argc > cp->maxargs) 2582e192b24SSimon Glass return CMD_RET_USAGE; 2592e192b24SSimon Glass if (flag == CMD_FLAG_REPEAT && !cp->repeatable) 2602e192b24SSimon Glass return CMD_RET_SUCCESS; 2612e192b24SSimon Glass 2622e192b24SSimon Glass mmc = init_mmc_device(curr_device, false); 2632e192b24SSimon Glass if (!mmc) 2642e192b24SSimon Glass return CMD_RET_FAILURE; 2652e192b24SSimon Glass 2662e192b24SSimon Glass if (!(mmc->version & MMC_VERSION_MMC)) { 2672e192b24SSimon Glass printf("It is not a EMMC device\n"); 2682e192b24SSimon Glass return CMD_RET_FAILURE; 2692e192b24SSimon Glass } 2702e192b24SSimon Glass if (mmc->version < MMC_VERSION_4_41) { 2712e192b24SSimon Glass printf("RPMB not supported before version 4.41\n"); 2722e192b24SSimon Glass return CMD_RET_FAILURE; 2732e192b24SSimon Glass } 2742e192b24SSimon Glass /* Switch to the RPMB partition */ 2754dc80c87SKever Yang #ifndef CONFIG_BLK 276b955e42bSMarek Vasut original_part = mmc->block_dev.hwpart; 2774dc80c87SKever Yang #else 2784dc80c87SKever Yang original_part = mmc_get_blk_desc(mmc)->hwpart; 2794dc80c87SKever Yang #endif 28069f45cd5SSimon Glass if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, MMC_PART_RPMB) != 28169f45cd5SSimon Glass 0) 2822e192b24SSimon Glass return CMD_RET_FAILURE; 2832e192b24SSimon Glass ret = cp->cmd(cmdtp, flag, argc, argv); 2842e192b24SSimon Glass 2852e192b24SSimon Glass /* Return to original partition */ 28669f45cd5SSimon Glass if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, original_part) != 28769f45cd5SSimon Glass 0) 2882e192b24SSimon Glass return CMD_RET_FAILURE; 2892e192b24SSimon Glass return ret; 2902e192b24SSimon Glass } 2912e192b24SSimon Glass #endif 2922e192b24SSimon Glass 2932e192b24SSimon Glass static int do_mmc_read(cmd_tbl_t *cmdtp, int flag, 2942e192b24SSimon Glass int argc, char * const argv[]) 2952e192b24SSimon Glass { 2962e192b24SSimon Glass struct mmc *mmc; 2972e192b24SSimon Glass u32 blk, cnt, n; 2982e192b24SSimon Glass void *addr; 2992e192b24SSimon Glass 3002e192b24SSimon Glass if (argc != 4) 3012e192b24SSimon Glass return CMD_RET_USAGE; 3022e192b24SSimon Glass 3032e192b24SSimon Glass addr = (void *)simple_strtoul(argv[1], NULL, 16); 3042e192b24SSimon Glass blk = simple_strtoul(argv[2], NULL, 16); 3052e192b24SSimon Glass cnt = simple_strtoul(argv[3], NULL, 16); 3062e192b24SSimon Glass 3072e192b24SSimon Glass mmc = init_mmc_device(curr_device, false); 3082e192b24SSimon Glass if (!mmc) 3092e192b24SSimon Glass return CMD_RET_FAILURE; 3102e192b24SSimon Glass 3112e192b24SSimon Glass printf("\nMMC read: dev # %d, block # %d, count %d ... ", 3122e192b24SSimon Glass curr_device, blk, cnt); 3132e192b24SSimon Glass 314c40fdca6SSimon Glass n = blk_dread(mmc_get_blk_desc(mmc), blk, cnt, addr); 3152e192b24SSimon Glass printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR"); 3162e192b24SSimon Glass 3172e192b24SSimon Glass return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE; 3182e192b24SSimon Glass } 319e6fa5a54SJean-Jacques Hiblot 320c232d14dSAlex Kiernan #if CONFIG_IS_ENABLED(CMD_MMC_SWRITE) 321732bc7ceSJassi Brar static lbaint_t mmc_sparse_write(struct sparse_storage *info, lbaint_t blk, 322732bc7ceSJassi Brar lbaint_t blkcnt, const void *buffer) 323732bc7ceSJassi Brar { 324732bc7ceSJassi Brar struct blk_desc *dev_desc = info->priv; 325732bc7ceSJassi Brar 326732bc7ceSJassi Brar return blk_dwrite(dev_desc, blk, blkcnt, buffer); 327732bc7ceSJassi Brar } 328732bc7ceSJassi Brar 329732bc7ceSJassi Brar static lbaint_t mmc_sparse_reserve(struct sparse_storage *info, 330732bc7ceSJassi Brar lbaint_t blk, lbaint_t blkcnt) 331732bc7ceSJassi Brar { 332732bc7ceSJassi Brar return blkcnt; 333732bc7ceSJassi Brar } 334732bc7ceSJassi Brar 335732bc7ceSJassi Brar static int do_mmc_sparse_write(cmd_tbl_t *cmdtp, int flag, 336732bc7ceSJassi Brar int argc, char * const argv[]) 337732bc7ceSJassi Brar { 338732bc7ceSJassi Brar struct sparse_storage sparse; 339732bc7ceSJassi Brar struct blk_desc *dev_desc; 340732bc7ceSJassi Brar struct mmc *mmc; 341732bc7ceSJassi Brar char dest[11]; 342732bc7ceSJassi Brar void *addr; 343732bc7ceSJassi Brar u32 blk; 344732bc7ceSJassi Brar 345732bc7ceSJassi Brar if (argc != 3) 346732bc7ceSJassi Brar return CMD_RET_USAGE; 347732bc7ceSJassi Brar 348732bc7ceSJassi Brar addr = (void *)simple_strtoul(argv[1], NULL, 16); 349732bc7ceSJassi Brar blk = simple_strtoul(argv[2], NULL, 16); 350732bc7ceSJassi Brar 351732bc7ceSJassi Brar if (!is_sparse_image(addr)) { 352732bc7ceSJassi Brar printf("Not a sparse image\n"); 353732bc7ceSJassi Brar return CMD_RET_FAILURE; 354732bc7ceSJassi Brar } 355732bc7ceSJassi Brar 356732bc7ceSJassi Brar mmc = init_mmc_device(curr_device, false); 357732bc7ceSJassi Brar if (!mmc) 358732bc7ceSJassi Brar return CMD_RET_FAILURE; 359732bc7ceSJassi Brar 360732bc7ceSJassi Brar printf("\nMMC Sparse write: dev # %d, block # %d ... ", 361732bc7ceSJassi Brar curr_device, blk); 362732bc7ceSJassi Brar 363732bc7ceSJassi Brar if (mmc_getwp(mmc) == 1) { 364732bc7ceSJassi Brar printf("Error: card is write protected!\n"); 365732bc7ceSJassi Brar return CMD_RET_FAILURE; 366732bc7ceSJassi Brar } 367732bc7ceSJassi Brar 368732bc7ceSJassi Brar dev_desc = mmc_get_blk_desc(mmc); 369732bc7ceSJassi Brar sparse.priv = dev_desc; 370732bc7ceSJassi Brar sparse.blksz = 512; 371732bc7ceSJassi Brar sparse.start = blk; 372732bc7ceSJassi Brar sparse.size = dev_desc->lba - blk; 373732bc7ceSJassi Brar sparse.write = mmc_sparse_write; 374732bc7ceSJassi Brar sparse.reserve = mmc_sparse_reserve; 375732bc7ceSJassi Brar sparse.mssg = NULL; 376732bc7ceSJassi Brar sprintf(dest, "0x" LBAF, sparse.start * sparse.blksz); 377732bc7ceSJassi Brar 378c4ded03eSAlex Kiernan if (write_sparse_image(&sparse, dest, addr, NULL)) 379732bc7ceSJassi Brar return CMD_RET_FAILURE; 380732bc7ceSJassi Brar else 381732bc7ceSJassi Brar return CMD_RET_SUCCESS; 382732bc7ceSJassi Brar } 383732bc7ceSJassi Brar #endif 384732bc7ceSJassi Brar 385c232d14dSAlex Kiernan #if CONFIG_IS_ENABLED(MMC_WRITE) 3862e192b24SSimon Glass static int do_mmc_write(cmd_tbl_t *cmdtp, int flag, 3872e192b24SSimon Glass int argc, char * const argv[]) 3882e192b24SSimon Glass { 3892e192b24SSimon Glass struct mmc *mmc; 3902e192b24SSimon Glass u32 blk, cnt, n; 3912e192b24SSimon Glass void *addr; 3922e192b24SSimon Glass 3932e192b24SSimon Glass if (argc != 4) 3942e192b24SSimon Glass return CMD_RET_USAGE; 3952e192b24SSimon Glass 3962e192b24SSimon Glass addr = (void *)simple_strtoul(argv[1], NULL, 16); 3972e192b24SSimon Glass blk = simple_strtoul(argv[2], NULL, 16); 3982e192b24SSimon Glass cnt = simple_strtoul(argv[3], NULL, 16); 3992e192b24SSimon Glass 4002e192b24SSimon Glass mmc = init_mmc_device(curr_device, false); 4012e192b24SSimon Glass if (!mmc) 4022e192b24SSimon Glass return CMD_RET_FAILURE; 4032e192b24SSimon Glass 4042e192b24SSimon Glass printf("\nMMC write: dev # %d, block # %d, count %d ... ", 4052e192b24SSimon Glass curr_device, blk, cnt); 4062e192b24SSimon Glass 4072e192b24SSimon Glass if (mmc_getwp(mmc) == 1) { 4082e192b24SSimon Glass printf("Error: card is write protected!\n"); 4092e192b24SSimon Glass return CMD_RET_FAILURE; 4102e192b24SSimon Glass } 411c40fdca6SSimon Glass n = blk_dwrite(mmc_get_blk_desc(mmc), blk, cnt, addr); 4122e192b24SSimon Glass printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR"); 4132e192b24SSimon Glass 4142e192b24SSimon Glass return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE; 4152e192b24SSimon Glass } 4162e192b24SSimon Glass static int do_mmc_erase(cmd_tbl_t *cmdtp, int flag, 4172e192b24SSimon Glass int argc, char * const argv[]) 4182e192b24SSimon Glass { 4192e192b24SSimon Glass struct mmc *mmc; 4202e192b24SSimon Glass u32 blk, cnt, n; 4212e192b24SSimon Glass 4222e192b24SSimon Glass if (argc != 3) 4232e192b24SSimon Glass return CMD_RET_USAGE; 4242e192b24SSimon Glass 4252e192b24SSimon Glass blk = simple_strtoul(argv[1], NULL, 16); 4262e192b24SSimon Glass cnt = simple_strtoul(argv[2], NULL, 16); 4272e192b24SSimon Glass 4282e192b24SSimon Glass mmc = init_mmc_device(curr_device, false); 4292e192b24SSimon Glass if (!mmc) 4302e192b24SSimon Glass return CMD_RET_FAILURE; 4312e192b24SSimon Glass 4322e192b24SSimon Glass printf("\nMMC erase: dev # %d, block # %d, count %d ... ", 4332e192b24SSimon Glass curr_device, blk, cnt); 4342e192b24SSimon Glass 4352e192b24SSimon Glass if (mmc_getwp(mmc) == 1) { 4362e192b24SSimon Glass printf("Error: card is write protected!\n"); 4372e192b24SSimon Glass return CMD_RET_FAILURE; 4382e192b24SSimon Glass } 439c40fdca6SSimon Glass n = blk_derase(mmc_get_blk_desc(mmc), blk, cnt); 4402e192b24SSimon Glass printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR"); 4412e192b24SSimon Glass 4422e192b24SSimon Glass return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE; 4432e192b24SSimon Glass } 444e6fa5a54SJean-Jacques Hiblot #endif 445e6fa5a54SJean-Jacques Hiblot 4462e192b24SSimon Glass static int do_mmc_rescan(cmd_tbl_t *cmdtp, int flag, 4472e192b24SSimon Glass int argc, char * const argv[]) 4482e192b24SSimon Glass { 4492e192b24SSimon Glass struct mmc *mmc; 4502e192b24SSimon Glass 4512e192b24SSimon Glass mmc = init_mmc_device(curr_device, true); 4522e192b24SSimon Glass if (!mmc) 4532e192b24SSimon Glass return CMD_RET_FAILURE; 4542e192b24SSimon Glass 4552e192b24SSimon Glass return CMD_RET_SUCCESS; 4562e192b24SSimon Glass } 4572e192b24SSimon Glass static int do_mmc_part(cmd_tbl_t *cmdtp, int flag, 4582e192b24SSimon Glass int argc, char * const argv[]) 4592e192b24SSimon Glass { 4604101f687SSimon Glass struct blk_desc *mmc_dev; 4612e192b24SSimon Glass struct mmc *mmc; 4622e192b24SSimon Glass 4632e192b24SSimon Glass mmc = init_mmc_device(curr_device, false); 4642e192b24SSimon Glass if (!mmc) 4652e192b24SSimon Glass return CMD_RET_FAILURE; 4662e192b24SSimon Glass 4673c457f4dSSimon Glass mmc_dev = blk_get_devnum_by_type(IF_TYPE_MMC, curr_device); 4682e192b24SSimon Glass if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) { 4693e8bd469SSimon Glass part_print(mmc_dev); 4702e192b24SSimon Glass return CMD_RET_SUCCESS; 4712e192b24SSimon Glass } 4722e192b24SSimon Glass 4732e192b24SSimon Glass puts("get mmc type error!\n"); 4742e192b24SSimon Glass return CMD_RET_FAILURE; 4752e192b24SSimon Glass } 4762e192b24SSimon Glass static int do_mmc_dev(cmd_tbl_t *cmdtp, int flag, 4772e192b24SSimon Glass int argc, char * const argv[]) 4782e192b24SSimon Glass { 4792e192b24SSimon Glass int dev, part = 0, ret; 4802e192b24SSimon Glass struct mmc *mmc; 4812e192b24SSimon Glass 4822e192b24SSimon Glass if (argc == 1) { 4832e192b24SSimon Glass dev = curr_device; 4842e192b24SSimon Glass } else if (argc == 2) { 4852e192b24SSimon Glass dev = simple_strtoul(argv[1], NULL, 10); 4862e192b24SSimon Glass } else if (argc == 3) { 4872e192b24SSimon Glass dev = (int)simple_strtoul(argv[1], NULL, 10); 4882e192b24SSimon Glass part = (int)simple_strtoul(argv[2], NULL, 10); 4892e192b24SSimon Glass if (part > PART_ACCESS_MASK) { 4902e192b24SSimon Glass printf("#part_num shouldn't be larger than %d\n", 4912e192b24SSimon Glass PART_ACCESS_MASK); 4922e192b24SSimon Glass return CMD_RET_FAILURE; 4932e192b24SSimon Glass } 4942e192b24SSimon Glass } else { 4952e192b24SSimon Glass return CMD_RET_USAGE; 4962e192b24SSimon Glass } 4972e192b24SSimon Glass 4982e192b24SSimon Glass mmc = init_mmc_device(dev, true); 4992e192b24SSimon Glass if (!mmc) 5002e192b24SSimon Glass return CMD_RET_FAILURE; 5012e192b24SSimon Glass 50269f45cd5SSimon Glass ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part); 5032e192b24SSimon Glass printf("switch to partitions #%d, %s\n", 5042e192b24SSimon Glass part, (!ret) ? "OK" : "ERROR"); 5052e192b24SSimon Glass if (ret) 5062e192b24SSimon Glass return 1; 5072e192b24SSimon Glass 5082e192b24SSimon Glass curr_device = dev; 5092e192b24SSimon Glass if (mmc->part_config == MMCPART_NOAVAILABLE) 5102e192b24SSimon Glass printf("mmc%d is current device\n", curr_device); 5112e192b24SSimon Glass else 5122e192b24SSimon Glass printf("mmc%d(part %d) is current device\n", 513c40fdca6SSimon Glass curr_device, mmc_get_blk_desc(mmc)->hwpart); 5142e192b24SSimon Glass 5152e192b24SSimon Glass return CMD_RET_SUCCESS; 5162e192b24SSimon Glass } 5172e192b24SSimon Glass static int do_mmc_list(cmd_tbl_t *cmdtp, int flag, 5182e192b24SSimon Glass int argc, char * const argv[]) 5192e192b24SSimon Glass { 5202e192b24SSimon Glass print_mmc_devices('\n'); 5212e192b24SSimon Glass return CMD_RET_SUCCESS; 5222e192b24SSimon Glass } 5232e192b24SSimon Glass 524cf17789eSJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING) 5252e192b24SSimon Glass static int parse_hwpart_user(struct mmc_hwpart_conf *pconf, 5262e192b24SSimon Glass int argc, char * const argv[]) 5272e192b24SSimon Glass { 5282e192b24SSimon Glass int i = 0; 5292e192b24SSimon Glass 5302e192b24SSimon Glass memset(&pconf->user, 0, sizeof(pconf->user)); 5312e192b24SSimon Glass 5322e192b24SSimon Glass while (i < argc) { 5332e192b24SSimon Glass if (!strcmp(argv[i], "enh")) { 5342e192b24SSimon Glass if (i + 2 >= argc) 5352e192b24SSimon Glass return -1; 5362e192b24SSimon Glass pconf->user.enh_start = 5372e192b24SSimon Glass simple_strtoul(argv[i+1], NULL, 10); 5382e192b24SSimon Glass pconf->user.enh_size = 5392e192b24SSimon Glass simple_strtoul(argv[i+2], NULL, 10); 5402e192b24SSimon Glass i += 3; 5412e192b24SSimon Glass } else if (!strcmp(argv[i], "wrrel")) { 5422e192b24SSimon Glass if (i + 1 >= argc) 5432e192b24SSimon Glass return -1; 5442e192b24SSimon Glass pconf->user.wr_rel_change = 1; 5452e192b24SSimon Glass if (!strcmp(argv[i+1], "on")) 5462e192b24SSimon Glass pconf->user.wr_rel_set = 1; 5472e192b24SSimon Glass else if (!strcmp(argv[i+1], "off")) 5482e192b24SSimon Glass pconf->user.wr_rel_set = 0; 5492e192b24SSimon Glass else 5502e192b24SSimon Glass return -1; 5512e192b24SSimon Glass i += 2; 5522e192b24SSimon Glass } else { 5532e192b24SSimon Glass break; 5542e192b24SSimon Glass } 5552e192b24SSimon Glass } 5562e192b24SSimon Glass return i; 5572e192b24SSimon Glass } 5582e192b24SSimon Glass 5592e192b24SSimon Glass static int parse_hwpart_gp(struct mmc_hwpart_conf *pconf, int pidx, 5602e192b24SSimon Glass int argc, char * const argv[]) 5612e192b24SSimon Glass { 5622e192b24SSimon Glass int i; 5632e192b24SSimon Glass 5642e192b24SSimon Glass memset(&pconf->gp_part[pidx], 0, sizeof(pconf->gp_part[pidx])); 5652e192b24SSimon Glass 5662e192b24SSimon Glass if (1 >= argc) 5672e192b24SSimon Glass return -1; 5682e192b24SSimon Glass pconf->gp_part[pidx].size = simple_strtoul(argv[0], NULL, 10); 5692e192b24SSimon Glass 5702e192b24SSimon Glass i = 1; 5712e192b24SSimon Glass while (i < argc) { 5722e192b24SSimon Glass if (!strcmp(argv[i], "enh")) { 5732e192b24SSimon Glass pconf->gp_part[pidx].enhanced = 1; 5742e192b24SSimon Glass i += 1; 5752e192b24SSimon Glass } else if (!strcmp(argv[i], "wrrel")) { 5762e192b24SSimon Glass if (i + 1 >= argc) 5772e192b24SSimon Glass return -1; 5782e192b24SSimon Glass pconf->gp_part[pidx].wr_rel_change = 1; 5792e192b24SSimon Glass if (!strcmp(argv[i+1], "on")) 5802e192b24SSimon Glass pconf->gp_part[pidx].wr_rel_set = 1; 5812e192b24SSimon Glass else if (!strcmp(argv[i+1], "off")) 5822e192b24SSimon Glass pconf->gp_part[pidx].wr_rel_set = 0; 5832e192b24SSimon Glass else 5842e192b24SSimon Glass return -1; 5852e192b24SSimon Glass i += 2; 5862e192b24SSimon Glass } else { 5872e192b24SSimon Glass break; 5882e192b24SSimon Glass } 5892e192b24SSimon Glass } 5902e192b24SSimon Glass return i; 5912e192b24SSimon Glass } 5922e192b24SSimon Glass 5932e192b24SSimon Glass static int do_mmc_hwpartition(cmd_tbl_t *cmdtp, int flag, 5942e192b24SSimon Glass int argc, char * const argv[]) 5952e192b24SSimon Glass { 5962e192b24SSimon Glass struct mmc *mmc; 5972e192b24SSimon Glass struct mmc_hwpart_conf pconf = { }; 5982e192b24SSimon Glass enum mmc_hwpart_conf_mode mode = MMC_HWPART_CONF_CHECK; 5992e192b24SSimon Glass int i, r, pidx; 6002e192b24SSimon Glass 6012e192b24SSimon Glass mmc = init_mmc_device(curr_device, false); 6022e192b24SSimon Glass if (!mmc) 6032e192b24SSimon Glass return CMD_RET_FAILURE; 6042e192b24SSimon Glass 6052e192b24SSimon Glass if (argc < 1) 6062e192b24SSimon Glass return CMD_RET_USAGE; 6072e192b24SSimon Glass i = 1; 6082e192b24SSimon Glass while (i < argc) { 6092e192b24SSimon Glass if (!strcmp(argv[i], "user")) { 6102e192b24SSimon Glass i++; 6112e192b24SSimon Glass r = parse_hwpart_user(&pconf, argc-i, &argv[i]); 6122e192b24SSimon Glass if (r < 0) 6132e192b24SSimon Glass return CMD_RET_USAGE; 6142e192b24SSimon Glass i += r; 6152e192b24SSimon Glass } else if (!strncmp(argv[i], "gp", 2) && 6162e192b24SSimon Glass strlen(argv[i]) == 3 && 6172e192b24SSimon Glass argv[i][2] >= '1' && argv[i][2] <= '4') { 6182e192b24SSimon Glass pidx = argv[i][2] - '1'; 6192e192b24SSimon Glass i++; 6202e192b24SSimon Glass r = parse_hwpart_gp(&pconf, pidx, argc-i, &argv[i]); 6212e192b24SSimon Glass if (r < 0) 6222e192b24SSimon Glass return CMD_RET_USAGE; 6232e192b24SSimon Glass i += r; 6242e192b24SSimon Glass } else if (!strcmp(argv[i], "check")) { 6252e192b24SSimon Glass mode = MMC_HWPART_CONF_CHECK; 6262e192b24SSimon Glass i++; 6272e192b24SSimon Glass } else if (!strcmp(argv[i], "set")) { 6282e192b24SSimon Glass mode = MMC_HWPART_CONF_SET; 6292e192b24SSimon Glass i++; 6302e192b24SSimon Glass } else if (!strcmp(argv[i], "complete")) { 6312e192b24SSimon Glass mode = MMC_HWPART_CONF_COMPLETE; 6322e192b24SSimon Glass i++; 6332e192b24SSimon Glass } else { 6342e192b24SSimon Glass return CMD_RET_USAGE; 6352e192b24SSimon Glass } 6362e192b24SSimon Glass } 6372e192b24SSimon Glass 6382e192b24SSimon Glass puts("Partition configuration:\n"); 6392e192b24SSimon Glass if (pconf.user.enh_size) { 6402e192b24SSimon Glass puts("\tUser Enhanced Start: "); 6412e192b24SSimon Glass print_size(((u64)pconf.user.enh_start) << 9, "\n"); 6422e192b24SSimon Glass puts("\tUser Enhanced Size: "); 6432e192b24SSimon Glass print_size(((u64)pconf.user.enh_size) << 9, "\n"); 6442e192b24SSimon Glass } else { 6452e192b24SSimon Glass puts("\tNo enhanced user data area\n"); 6462e192b24SSimon Glass } 6472e192b24SSimon Glass if (pconf.user.wr_rel_change) 6482e192b24SSimon Glass printf("\tUser partition write reliability: %s\n", 6492e192b24SSimon Glass pconf.user.wr_rel_set ? "on" : "off"); 6502e192b24SSimon Glass for (pidx = 0; pidx < 4; pidx++) { 6512e192b24SSimon Glass if (pconf.gp_part[pidx].size) { 6522e192b24SSimon Glass printf("\tGP%i Capacity: ", pidx+1); 6532e192b24SSimon Glass print_size(((u64)pconf.gp_part[pidx].size) << 9, 6542e192b24SSimon Glass pconf.gp_part[pidx].enhanced ? 6552e192b24SSimon Glass " ENH\n" : "\n"); 6562e192b24SSimon Glass } else { 6572e192b24SSimon Glass printf("\tNo GP%i partition\n", pidx+1); 6582e192b24SSimon Glass } 6592e192b24SSimon Glass if (pconf.gp_part[pidx].wr_rel_change) 6602e192b24SSimon Glass printf("\tGP%i write reliability: %s\n", pidx+1, 6612e192b24SSimon Glass pconf.gp_part[pidx].wr_rel_set ? "on" : "off"); 6622e192b24SSimon Glass } 6632e192b24SSimon Glass 6642e192b24SSimon Glass if (!mmc_hwpart_config(mmc, &pconf, mode)) { 6652e192b24SSimon Glass if (mode == MMC_HWPART_CONF_COMPLETE) 6662e192b24SSimon Glass puts("Partitioning successful, " 6672e192b24SSimon Glass "power-cycle to make effective\n"); 6682e192b24SSimon Glass return CMD_RET_SUCCESS; 6692e192b24SSimon Glass } else { 6702e192b24SSimon Glass puts("Failed!\n"); 6712e192b24SSimon Glass return CMD_RET_FAILURE; 6722e192b24SSimon Glass } 6732e192b24SSimon Glass } 674cf17789eSJean-Jacques Hiblot #endif 6752e192b24SSimon Glass 6762e192b24SSimon Glass #ifdef CONFIG_SUPPORT_EMMC_BOOT 6772e192b24SSimon Glass static int do_mmc_bootbus(cmd_tbl_t *cmdtp, int flag, 6782e192b24SSimon Glass int argc, char * const argv[]) 6792e192b24SSimon Glass { 6802e192b24SSimon Glass int dev; 6812e192b24SSimon Glass struct mmc *mmc; 6822e192b24SSimon Glass u8 width, reset, mode; 6832e192b24SSimon Glass 6842e192b24SSimon Glass if (argc != 5) 6852e192b24SSimon Glass return CMD_RET_USAGE; 6862e192b24SSimon Glass dev = simple_strtoul(argv[1], NULL, 10); 6872e192b24SSimon Glass width = simple_strtoul(argv[2], NULL, 10); 6882e192b24SSimon Glass reset = simple_strtoul(argv[3], NULL, 10); 6892e192b24SSimon Glass mode = simple_strtoul(argv[4], NULL, 10); 6902e192b24SSimon Glass 6912e192b24SSimon Glass mmc = init_mmc_device(dev, false); 6922e192b24SSimon Glass if (!mmc) 6932e192b24SSimon Glass return CMD_RET_FAILURE; 6942e192b24SSimon Glass 6952e192b24SSimon Glass if (IS_SD(mmc)) { 6962e192b24SSimon Glass puts("BOOT_BUS_WIDTH only exists on eMMC\n"); 6972e192b24SSimon Glass return CMD_RET_FAILURE; 6982e192b24SSimon Glass } 6992e192b24SSimon Glass 7002e192b24SSimon Glass /* acknowledge to be sent during boot operation */ 7012e192b24SSimon Glass return mmc_set_boot_bus_width(mmc, width, reset, mode); 7022e192b24SSimon Glass } 7032e192b24SSimon Glass static int do_mmc_boot_resize(cmd_tbl_t *cmdtp, int flag, 7042e192b24SSimon Glass int argc, char * const argv[]) 7052e192b24SSimon Glass { 7062e192b24SSimon Glass int dev; 7072e192b24SSimon Glass struct mmc *mmc; 7082e192b24SSimon Glass u32 bootsize, rpmbsize; 7092e192b24SSimon Glass 7102e192b24SSimon Glass if (argc != 4) 7112e192b24SSimon Glass return CMD_RET_USAGE; 7122e192b24SSimon Glass dev = simple_strtoul(argv[1], NULL, 10); 7132e192b24SSimon Glass bootsize = simple_strtoul(argv[2], NULL, 10); 7142e192b24SSimon Glass rpmbsize = simple_strtoul(argv[3], NULL, 10); 7152e192b24SSimon Glass 7162e192b24SSimon Glass mmc = init_mmc_device(dev, false); 7172e192b24SSimon Glass if (!mmc) 7182e192b24SSimon Glass return CMD_RET_FAILURE; 7192e192b24SSimon Glass 7202e192b24SSimon Glass if (IS_SD(mmc)) { 7212e192b24SSimon Glass printf("It is not a EMMC device\n"); 7222e192b24SSimon Glass return CMD_RET_FAILURE; 7232e192b24SSimon Glass } 7242e192b24SSimon Glass 7252e192b24SSimon Glass if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) { 7262e192b24SSimon Glass printf("EMMC boot partition Size change Failed.\n"); 7272e192b24SSimon Glass return CMD_RET_FAILURE; 7282e192b24SSimon Glass } 7292e192b24SSimon Glass 7302e192b24SSimon Glass printf("EMMC boot partition Size %d MB\n", bootsize); 7312e192b24SSimon Glass printf("EMMC RPMB partition Size %d MB\n", rpmbsize); 7322e192b24SSimon Glass return CMD_RET_SUCCESS; 7332e192b24SSimon Glass } 734bdb60996SAngelo Dureghello 735bdb60996SAngelo Dureghello static int mmc_partconf_print(struct mmc *mmc) 736bdb60996SAngelo Dureghello { 737bdb60996SAngelo Dureghello u8 ack, access, part; 738bdb60996SAngelo Dureghello 739bdb60996SAngelo Dureghello if (mmc->part_config == MMCPART_NOAVAILABLE) { 740bdb60996SAngelo Dureghello printf("No part_config info for ver. 0x%x\n", mmc->version); 741bdb60996SAngelo Dureghello return CMD_RET_FAILURE; 742bdb60996SAngelo Dureghello } 743bdb60996SAngelo Dureghello 744bdb60996SAngelo Dureghello access = EXT_CSD_EXTRACT_PARTITION_ACCESS(mmc->part_config); 745bdb60996SAngelo Dureghello ack = EXT_CSD_EXTRACT_BOOT_ACK(mmc->part_config); 746bdb60996SAngelo Dureghello part = EXT_CSD_EXTRACT_BOOT_PART(mmc->part_config); 747bdb60996SAngelo Dureghello 748bdb60996SAngelo Dureghello printf("EXT_CSD[179], PARTITION_CONFIG:\n" 749bdb60996SAngelo Dureghello "BOOT_ACK: 0x%x\n" 750bdb60996SAngelo Dureghello "BOOT_PARTITION_ENABLE: 0x%x\n" 751bdb60996SAngelo Dureghello "PARTITION_ACCESS: 0x%x\n", ack, part, access); 752bdb60996SAngelo Dureghello 753bdb60996SAngelo Dureghello return CMD_RET_SUCCESS; 754bdb60996SAngelo Dureghello } 755bdb60996SAngelo Dureghello 7562e192b24SSimon Glass static int do_mmc_partconf(cmd_tbl_t *cmdtp, int flag, 7572e192b24SSimon Glass int argc, char * const argv[]) 7582e192b24SSimon Glass { 7592e192b24SSimon Glass int dev; 7602e192b24SSimon Glass struct mmc *mmc; 7612e192b24SSimon Glass u8 ack, part_num, access; 7622e192b24SSimon Glass 763bdb60996SAngelo Dureghello if (argc != 2 && argc != 5) 7642e192b24SSimon Glass return CMD_RET_USAGE; 7652e192b24SSimon Glass 7662e192b24SSimon Glass dev = simple_strtoul(argv[1], NULL, 10); 7672e192b24SSimon Glass 7682e192b24SSimon Glass mmc = init_mmc_device(dev, false); 7692e192b24SSimon Glass if (!mmc) 7702e192b24SSimon Glass return CMD_RET_FAILURE; 7712e192b24SSimon Glass 7722e192b24SSimon Glass if (IS_SD(mmc)) { 7732e192b24SSimon Glass puts("PARTITION_CONFIG only exists on eMMC\n"); 7742e192b24SSimon Glass return CMD_RET_FAILURE; 7752e192b24SSimon Glass } 7762e192b24SSimon Glass 777bdb60996SAngelo Dureghello if (argc == 2) 778bdb60996SAngelo Dureghello return mmc_partconf_print(mmc); 779bdb60996SAngelo Dureghello 780bdb60996SAngelo Dureghello ack = simple_strtoul(argv[2], NULL, 10); 781bdb60996SAngelo Dureghello part_num = simple_strtoul(argv[3], NULL, 10); 782bdb60996SAngelo Dureghello access = simple_strtoul(argv[4], NULL, 10); 783bdb60996SAngelo Dureghello 7842e192b24SSimon Glass /* acknowledge to be sent during boot operation */ 7852e192b24SSimon Glass return mmc_set_part_conf(mmc, ack, part_num, access); 7862e192b24SSimon Glass } 7872e192b24SSimon Glass static int do_mmc_rst_func(cmd_tbl_t *cmdtp, int flag, 7882e192b24SSimon Glass int argc, char * const argv[]) 7892e192b24SSimon Glass { 7902e192b24SSimon Glass int dev; 7912e192b24SSimon Glass struct mmc *mmc; 7922e192b24SSimon Glass u8 enable; 7932e192b24SSimon Glass 7942e192b24SSimon Glass /* 7952e192b24SSimon Glass * Set the RST_n_ENABLE bit of RST_n_FUNCTION 7962e192b24SSimon Glass * The only valid values are 0x0, 0x1 and 0x2 and writing 7972e192b24SSimon Glass * a value of 0x1 or 0x2 sets the value permanently. 7982e192b24SSimon Glass */ 7992e192b24SSimon Glass if (argc != 3) 8002e192b24SSimon Glass return CMD_RET_USAGE; 8012e192b24SSimon Glass 8022e192b24SSimon Glass dev = simple_strtoul(argv[1], NULL, 10); 8032e192b24SSimon Glass enable = simple_strtoul(argv[2], NULL, 10); 8042e192b24SSimon Glass 8052e192b24SSimon Glass if (enable > 2) { 8062e192b24SSimon Glass puts("Invalid RST_n_ENABLE value\n"); 8072e192b24SSimon Glass return CMD_RET_USAGE; 8082e192b24SSimon Glass } 8092e192b24SSimon Glass 8102e192b24SSimon Glass mmc = init_mmc_device(dev, false); 8112e192b24SSimon Glass if (!mmc) 8122e192b24SSimon Glass return CMD_RET_FAILURE; 8132e192b24SSimon Glass 8142e192b24SSimon Glass if (IS_SD(mmc)) { 8152e192b24SSimon Glass puts("RST_n_FUNCTION only exists on eMMC\n"); 8162e192b24SSimon Glass return CMD_RET_FAILURE; 8172e192b24SSimon Glass } 8182e192b24SSimon Glass 8192e192b24SSimon Glass return mmc_set_rst_n_function(mmc, enable); 8202e192b24SSimon Glass } 8212e192b24SSimon Glass #endif 8222e192b24SSimon Glass static int do_mmc_setdsr(cmd_tbl_t *cmdtp, int flag, 8232e192b24SSimon Glass int argc, char * const argv[]) 8242e192b24SSimon Glass { 8252e192b24SSimon Glass struct mmc *mmc; 8262e192b24SSimon Glass u32 val; 8272e192b24SSimon Glass int ret; 8282e192b24SSimon Glass 8292e192b24SSimon Glass if (argc != 2) 8302e192b24SSimon Glass return CMD_RET_USAGE; 83184c1dfe4SMarkus Niebel val = simple_strtoul(argv[1], NULL, 16); 8322e192b24SSimon Glass 8332e192b24SSimon Glass mmc = find_mmc_device(curr_device); 8342e192b24SSimon Glass if (!mmc) { 8352e192b24SSimon Glass printf("no mmc device at slot %x\n", curr_device); 8362e192b24SSimon Glass return CMD_RET_FAILURE; 8372e192b24SSimon Glass } 8382e192b24SSimon Glass ret = mmc_set_dsr(mmc, val); 8392e192b24SSimon Glass printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR"); 8402e192b24SSimon Glass if (!ret) { 8412e192b24SSimon Glass mmc->has_init = 0; 8422e192b24SSimon Glass if (mmc_init(mmc)) 8432e192b24SSimon Glass return CMD_RET_FAILURE; 8442e192b24SSimon Glass else 8452e192b24SSimon Glass return CMD_RET_SUCCESS; 8462e192b24SSimon Glass } 8472e192b24SSimon Glass return ret; 8482e192b24SSimon Glass } 8492e192b24SSimon Glass 850cd3d4880STomas Melin #ifdef CONFIG_CMD_BKOPS_ENABLE 851cd3d4880STomas Melin static int do_mmc_bkops_enable(cmd_tbl_t *cmdtp, int flag, 852cd3d4880STomas Melin int argc, char * const argv[]) 853cd3d4880STomas Melin { 854cd3d4880STomas Melin int dev; 855cd3d4880STomas Melin struct mmc *mmc; 856cd3d4880STomas Melin 857cd3d4880STomas Melin if (argc != 2) 858cd3d4880STomas Melin return CMD_RET_USAGE; 859cd3d4880STomas Melin 860cd3d4880STomas Melin dev = simple_strtoul(argv[1], NULL, 10); 861cd3d4880STomas Melin 862cd3d4880STomas Melin mmc = init_mmc_device(dev, false); 863cd3d4880STomas Melin if (!mmc) 864cd3d4880STomas Melin return CMD_RET_FAILURE; 865cd3d4880STomas Melin 866cd3d4880STomas Melin if (IS_SD(mmc)) { 867cd3d4880STomas Melin puts("BKOPS_EN only exists on eMMC\n"); 868cd3d4880STomas Melin return CMD_RET_FAILURE; 869cd3d4880STomas Melin } 870cd3d4880STomas Melin 871cd3d4880STomas Melin return mmc_set_bkops_enable(mmc); 872cd3d4880STomas Melin } 873cd3d4880STomas Melin #endif 874cd3d4880STomas Melin 8752e192b24SSimon Glass static cmd_tbl_t cmd_mmc[] = { 8762e192b24SSimon Glass U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""), 8772e192b24SSimon Glass U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""), 878e6fa5a54SJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MMC_WRITE) 8792e192b24SSimon Glass U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""), 8802e192b24SSimon Glass U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""), 881e6fa5a54SJean-Jacques Hiblot #endif 882c232d14dSAlex Kiernan #if CONFIG_IS_ENABLED(CMD_MMC_SWRITE) 883c232d14dSAlex Kiernan U_BOOT_CMD_MKENT(swrite, 3, 0, do_mmc_sparse_write, "", ""), 884c232d14dSAlex Kiernan #endif 8852e192b24SSimon Glass U_BOOT_CMD_MKENT(rescan, 1, 1, do_mmc_rescan, "", ""), 8862e192b24SSimon Glass U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""), 8872e192b24SSimon Glass U_BOOT_CMD_MKENT(dev, 3, 0, do_mmc_dev, "", ""), 8882e192b24SSimon Glass U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""), 889cf17789eSJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING) 8902e192b24SSimon Glass U_BOOT_CMD_MKENT(hwpartition, 28, 0, do_mmc_hwpartition, "", ""), 891cf17789eSJean-Jacques Hiblot #endif 8922e192b24SSimon Glass #ifdef CONFIG_SUPPORT_EMMC_BOOT 8932e192b24SSimon Glass U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""), 8942e192b24SSimon Glass U_BOOT_CMD_MKENT(bootpart-resize, 4, 0, do_mmc_boot_resize, "", ""), 8952e192b24SSimon Glass U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""), 8962e192b24SSimon Glass U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""), 8972e192b24SSimon Glass #endif 8985a7b11e6SAlex Kiernan #if CONFIG_IS_ENABLED(CMD_MMC_RPMB) 8992e192b24SSimon Glass U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""), 9002e192b24SSimon Glass #endif 9012e192b24SSimon Glass U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""), 902cd3d4880STomas Melin #ifdef CONFIG_CMD_BKOPS_ENABLE 903cd3d4880STomas Melin U_BOOT_CMD_MKENT(bkops-enable, 2, 0, do_mmc_bkops_enable, "", ""), 904cd3d4880STomas Melin #endif 9052e192b24SSimon Glass }; 9062e192b24SSimon Glass 9072e192b24SSimon Glass static int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 9082e192b24SSimon Glass { 9092e192b24SSimon Glass cmd_tbl_t *cp; 9102e192b24SSimon Glass 9112e192b24SSimon Glass cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc)); 9122e192b24SSimon Glass 9132e192b24SSimon Glass /* Drop the mmc command */ 9142e192b24SSimon Glass argc--; 9152e192b24SSimon Glass argv++; 9162e192b24SSimon Glass 9172e192b24SSimon Glass if (cp == NULL || argc > cp->maxargs) 9182e192b24SSimon Glass return CMD_RET_USAGE; 9192e192b24SSimon Glass if (flag == CMD_FLAG_REPEAT && !cp->repeatable) 9202e192b24SSimon Glass return CMD_RET_SUCCESS; 9212e192b24SSimon Glass 9222e192b24SSimon Glass if (curr_device < 0) { 9232e192b24SSimon Glass if (get_mmc_num() > 0) { 9242e192b24SSimon Glass curr_device = 0; 9252e192b24SSimon Glass } else { 9262e192b24SSimon Glass puts("No MMC device available\n"); 9272e192b24SSimon Glass return CMD_RET_FAILURE; 9282e192b24SSimon Glass } 9292e192b24SSimon Glass } 9302e192b24SSimon Glass return cp->cmd(cmdtp, flag, argc, argv); 9312e192b24SSimon Glass } 9322e192b24SSimon Glass 9332e192b24SSimon Glass U_BOOT_CMD( 9342e192b24SSimon Glass mmc, 29, 1, do_mmcops, 9352e192b24SSimon Glass "MMC sub system", 9362e192b24SSimon Glass "info - display info of the current MMC device\n" 9372e192b24SSimon Glass "mmc read addr blk# cnt\n" 9382e192b24SSimon Glass "mmc write addr blk# cnt\n" 939c232d14dSAlex Kiernan #if CONFIG_IS_ENABLED(CMD_MMC_SWRITE) 940732bc7ceSJassi Brar "mmc swrite addr blk#\n" 941732bc7ceSJassi Brar #endif 9422e192b24SSimon Glass "mmc erase blk# cnt\n" 9432e192b24SSimon Glass "mmc rescan\n" 9442e192b24SSimon Glass "mmc part - lists available partition on current mmc device\n" 9452e192b24SSimon Glass "mmc dev [dev] [part] - show or set current mmc device [partition]\n" 9462e192b24SSimon Glass "mmc list - lists available devices\n" 94784593679SAlex Kiernan #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING) 9482e192b24SSimon Glass "mmc hwpartition [args...] - does hardware partitioning\n" 9492e192b24SSimon Glass " arguments (sizes in 512-byte blocks):\n" 9502e192b24SSimon Glass " [user [enh start cnt] [wrrel {on|off}]] - sets user data area attributes\n" 9512e192b24SSimon Glass " [gp1|gp2|gp3|gp4 cnt [enh] [wrrel {on|off}]] - general purpose partition\n" 9522e192b24SSimon Glass " [check|set|complete] - mode, complete set partitioning completed\n" 9532e192b24SSimon Glass " WARNING: Partitioning is a write-once setting once it is set to complete.\n" 9542e192b24SSimon Glass " Power cycling is required to initialize partitions after set to complete.\n" 95584593679SAlex Kiernan #endif 9562e192b24SSimon Glass #ifdef CONFIG_SUPPORT_EMMC_BOOT 9572e192b24SSimon Glass "mmc bootbus dev boot_bus_width reset_boot_bus_width boot_mode\n" 9582e192b24SSimon Glass " - Set the BOOT_BUS_WIDTH field of the specified device\n" 9592e192b24SSimon Glass "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n" 9602e192b24SSimon Glass " - Change sizes of boot and RPMB partitions of specified device\n" 961bdb60996SAngelo Dureghello "mmc partconf dev [boot_ack boot_partition partition_access]\n" 962bdb60996SAngelo Dureghello " - Show or change the bits of the PARTITION_CONFIG field of the specified device\n" 9632e192b24SSimon Glass "mmc rst-function dev value\n" 9642e192b24SSimon Glass " - Change the RST_n_FUNCTION field of the specified device\n" 9652e192b24SSimon Glass " WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n" 9662e192b24SSimon Glass #endif 9675a7b11e6SAlex Kiernan #if CONFIG_IS_ENABLED(CMD_MMC_RPMB) 9682e192b24SSimon Glass "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n" 9692e192b24SSimon Glass "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n" 9702e192b24SSimon Glass "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n" 9712e192b24SSimon Glass "mmc rpmb counter - read the value of the write counter\n" 9722e192b24SSimon Glass #endif 9732e192b24SSimon Glass "mmc setdsr <value> - set DSR register value\n" 974cd3d4880STomas Melin #ifdef CONFIG_CMD_BKOPS_ENABLE 975cd3d4880STomas Melin "mmc bkops-enable <dev> - enable background operations handshake on device\n" 976cd3d4880STomas Melin " WARNING: This is a write-once setting.\n" 977cd3d4880STomas Melin #endif 9782e192b24SSimon Glass ); 9792e192b24SSimon Glass 9802e192b24SSimon Glass /* Old command kept for compatibility. Same as 'mmc info' */ 9812e192b24SSimon Glass U_BOOT_CMD( 9822e192b24SSimon Glass mmcinfo, 1, 0, do_mmcinfo, 9832e192b24SSimon Glass "display MMC info", 9842e192b24SSimon Glass "- display info of the current MMC device" 9852e192b24SSimon Glass ); 986