common/cmd_mmc.c

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