Merge branch 'u-boot/master' into 'u-boot-arm/master'
[platform/kernel/u-boot.git] / 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 1;
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 1;
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 1;
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 0;
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         printf("Device: %s\n", mmc->cfg->name);
77         printf("Manufacturer ID: %x\n", mmc->cid[0] >> 24);
78         printf("OEM: %x\n", (mmc->cid[0] >> 8) & 0xffff);
79         printf("Name: %c%c%c%c%c \n", mmc->cid[0] & 0xff,
80                         (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
81                         (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
82
83         printf("Tran Speed: %d\n", mmc->tran_speed);
84         printf("Rd Block Len: %d\n", mmc->read_bl_len);
85
86         printf("%s version %d.%d\n", IS_SD(mmc) ? "SD" : "MMC",
87                         (mmc->version >> 8) & 0xf, mmc->version & 0xff);
88
89         printf("High Capacity: %s\n", mmc->high_capacity ? "Yes" : "No");
90         puts("Capacity: ");
91         print_size(mmc->capacity, "\n");
92
93         printf("Bus Width: %d-bit\n", mmc->bus_width);
94 }
95 static struct mmc *init_mmc_device(int dev, bool force_init)
96 {
97         struct mmc *mmc;
98         mmc = find_mmc_device(dev);
99         if (!mmc) {
100                 printf("no mmc device at slot %x\n", dev);
101                 return NULL;
102         }
103         if (force_init)
104                 mmc->has_init = 0;
105         if (mmc_init(mmc))
106                 return NULL;
107         return mmc;
108 }
109 static int do_mmcinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
110 {
111         struct mmc *mmc;
112
113         if (curr_device < 0) {
114                 if (get_mmc_num() > 0)
115                         curr_device = 0;
116                 else {
117                         puts("No MMC device available\n");
118                         return 1;
119                 }
120         }
121
122         mmc = init_mmc_device(curr_device, false);
123         if (!mmc)
124                 return CMD_RET_FAILURE;
125
126         print_mmcinfo(mmc);
127         return CMD_RET_SUCCESS;
128 }
129
130 #ifdef CONFIG_SUPPORT_EMMC_RPMB
131 static int confirm_key_prog(void)
132 {
133         puts("Warning: Programming authentication key can be done only once !\n"
134              "         Use this command only if you are sure of what you are doing,\n"
135              "Really perform the key programming? <y/N> ");
136         if (confirm_yesno())
137                 return 1;
138
139         puts("Authentication key programming aborted\n");
140         return 0;
141 }
142 static int do_mmcrpmb_key(cmd_tbl_t *cmdtp, int flag,
143                           int argc, char * const argv[])
144 {
145         void *key_addr;
146         struct mmc *mmc = find_mmc_device(curr_device);
147
148         if (argc != 2)
149                 return CMD_RET_USAGE;
150
151         key_addr = (void *)simple_strtoul(argv[1], NULL, 16);
152         if (!confirm_key_prog())
153                 return CMD_RET_FAILURE;
154         if (mmc_rpmb_set_key(mmc, key_addr)) {
155                 printf("ERROR - Key already programmed ?\n");
156                 return CMD_RET_FAILURE;
157         }
158         return CMD_RET_SUCCESS;
159 }
160 static int do_mmcrpmb_read(cmd_tbl_t *cmdtp, int flag,
161                            int argc, char * const argv[])
162 {
163         u16 blk, cnt;
164         void *addr;
165         int n;
166         void *key_addr = NULL;
167         struct mmc *mmc = find_mmc_device(curr_device);
168
169         if (argc < 4)
170                 return CMD_RET_USAGE;
171
172         addr = (void *)simple_strtoul(argv[1], NULL, 16);
173         blk = simple_strtoul(argv[2], NULL, 16);
174         cnt = simple_strtoul(argv[3], NULL, 16);
175
176         if (argc == 5)
177                 key_addr = (void *)simple_strtoul(argv[4], NULL, 16);
178
179         printf("\nMMC RPMB read: dev # %d, block # %d, count %d ... ",
180                curr_device, blk, cnt);
181         n =  mmc_rpmb_read(mmc, addr, blk, cnt, key_addr);
182
183         printf("%d RPMB blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
184         if (n != cnt)
185                 return CMD_RET_FAILURE;
186         return CMD_RET_SUCCESS;
187 }
188 static int do_mmcrpmb_write(cmd_tbl_t *cmdtp, int flag,
189                             int argc, char * const argv[])
190 {
191         u16 blk, cnt;
192         void *addr;
193         int n;
194         void *key_addr;
195         struct mmc *mmc = find_mmc_device(curr_device);
196
197         if (argc != 5)
198                 return CMD_RET_USAGE;
199
200         addr = (void *)simple_strtoul(argv[1], NULL, 16);
201         blk = simple_strtoul(argv[2], NULL, 16);
202         cnt = simple_strtoul(argv[3], NULL, 16);
203         key_addr = (void *)simple_strtoul(argv[4], NULL, 16);
204
205         printf("\nMMC RPMB write: dev # %d, block # %d, count %d ... ",
206                curr_device, blk, cnt);
207         n =  mmc_rpmb_write(mmc, addr, blk, cnt, key_addr);
208
209         printf("%d RPMB blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
210         if (n != cnt)
211                 return CMD_RET_FAILURE;
212         return CMD_RET_SUCCESS;
213 }
214 static int do_mmcrpmb_counter(cmd_tbl_t *cmdtp, int flag,
215                               int argc, char * const argv[])
216 {
217         unsigned long counter;
218         struct mmc *mmc = find_mmc_device(curr_device);
219
220         if (mmc_rpmb_get_counter(mmc, &counter))
221                 return CMD_RET_FAILURE;
222         printf("RPMB Write counter= %lx\n", counter);
223         return CMD_RET_SUCCESS;
224 }
225
226 static cmd_tbl_t cmd_rpmb[] = {
227         U_BOOT_CMD_MKENT(key, 2, 0, do_mmcrpmb_key, "", ""),
228         U_BOOT_CMD_MKENT(read, 5, 1, do_mmcrpmb_read, "", ""),
229         U_BOOT_CMD_MKENT(write, 5, 0, do_mmcrpmb_write, "", ""),
230         U_BOOT_CMD_MKENT(counter, 1, 1, do_mmcrpmb_counter, "", ""),
231 };
232
233 static int do_mmcrpmb(cmd_tbl_t *cmdtp, int flag,
234                       int argc, char * const argv[])
235 {
236         cmd_tbl_t *cp;
237         struct mmc *mmc;
238         char original_part;
239         int ret;
240
241         cp = find_cmd_tbl(argv[1], cmd_rpmb, ARRAY_SIZE(cmd_rpmb));
242
243         /* Drop the rpmb subcommand */
244         argc--;
245         argv++;
246
247         if (cp == NULL || argc > cp->maxargs)
248                 return CMD_RET_USAGE;
249         if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
250                 return CMD_RET_SUCCESS;
251
252         mmc = init_mmc_device(curr_device, false);
253         if (!mmc)
254                 return CMD_RET_FAILURE;
255
256         if (!(mmc->version & MMC_VERSION_MMC)) {
257                 printf("It is not a EMMC device\n");
258                 return CMD_RET_FAILURE;
259         }
260         if (mmc->version < MMC_VERSION_4_41) {
261                 printf("RPMB not supported before version 4.41\n");
262                 return CMD_RET_FAILURE;
263         }
264         /* Switch to the RPMB partition */
265         original_part = mmc->part_num;
266         if (mmc->part_num != MMC_PART_RPMB) {
267                 if (mmc_switch_part(curr_device, MMC_PART_RPMB) != 0)
268                         return CMD_RET_FAILURE;
269                 mmc->part_num = MMC_PART_RPMB;
270         }
271         ret = cp->cmd(cmdtp, flag, argc, argv);
272
273         /* Return to original partition */
274         if (mmc->part_num != original_part) {
275                 if (mmc_switch_part(curr_device, original_part) != 0)
276                         return CMD_RET_FAILURE;
277                 mmc->part_num = original_part;
278         }
279         return ret;
280 }
281 #endif
282
283 static int do_mmc_read(cmd_tbl_t *cmdtp, int flag,
284                        int argc, char * const argv[])
285 {
286         struct mmc *mmc;
287         u32 blk, cnt, n;
288         void *addr;
289
290         if (argc != 4)
291                 return CMD_RET_USAGE;
292
293         addr = (void *)simple_strtoul(argv[1], NULL, 16);
294         blk = simple_strtoul(argv[2], NULL, 16);
295         cnt = simple_strtoul(argv[3], NULL, 16);
296
297         mmc = init_mmc_device(curr_device, false);
298         if (!mmc)
299                 return CMD_RET_FAILURE;
300
301         printf("\nMMC read: dev # %d, block # %d, count %d ... ",
302                curr_device, blk, cnt);
303
304         n = mmc->block_dev.block_read(curr_device, blk, cnt, addr);
305         /* flush cache after read */
306         flush_cache((ulong)addr, cnt * 512); /* FIXME */
307         printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
308
309         return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
310 }
311 static int do_mmc_write(cmd_tbl_t *cmdtp, int flag,
312                         int argc, char * const argv[])
313 {
314         struct mmc *mmc;
315         u32 blk, cnt, n;
316         void *addr;
317
318         if (argc != 4)
319                 return CMD_RET_USAGE;
320
321         addr = (void *)simple_strtoul(argv[1], NULL, 16);
322         blk = simple_strtoul(argv[2], NULL, 16);
323         cnt = simple_strtoul(argv[3], NULL, 16);
324
325         mmc = init_mmc_device(curr_device, false);
326         if (!mmc)
327                 return CMD_RET_FAILURE;
328
329         printf("\nMMC write: dev # %d, block # %d, count %d ... ",
330                curr_device, blk, cnt);
331
332         if (mmc_getwp(mmc) == 1) {
333                 printf("Error: card is write protected!\n");
334                 return CMD_RET_FAILURE;
335         }
336         n = mmc->block_dev.block_write(curr_device, blk, cnt, addr);
337         printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
338
339         return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
340 }
341 static int do_mmc_erase(cmd_tbl_t *cmdtp, int flag,
342                         int argc, char * const argv[])
343 {
344         struct mmc *mmc;
345         u32 blk, cnt, n;
346
347         if (argc != 3)
348                 return CMD_RET_USAGE;
349
350         blk = simple_strtoul(argv[1], NULL, 16);
351         cnt = simple_strtoul(argv[2], NULL, 16);
352
353         mmc = init_mmc_device(curr_device, false);
354         if (!mmc)
355                 return CMD_RET_FAILURE;
356
357         printf("\nMMC erase: dev # %d, block # %d, count %d ... ",
358                curr_device, blk, cnt);
359
360         if (mmc_getwp(mmc) == 1) {
361                 printf("Error: card is write protected!\n");
362                 return CMD_RET_FAILURE;
363         }
364         n = mmc->block_dev.block_erase(curr_device, blk, cnt);
365         printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR");
366
367         return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
368 }
369 static int do_mmc_rescan(cmd_tbl_t *cmdtp, int flag,
370                          int argc, char * const argv[])
371 {
372         struct mmc *mmc;
373
374         mmc = init_mmc_device(curr_device, true);
375         if (!mmc)
376                 return CMD_RET_FAILURE;
377
378         return CMD_RET_SUCCESS;
379 }
380 static int do_mmc_part(cmd_tbl_t *cmdtp, int flag,
381                        int argc, char * const argv[])
382 {
383         block_dev_desc_t *mmc_dev;
384         struct mmc *mmc;
385
386         mmc = init_mmc_device(curr_device, false);
387         if (!mmc)
388                 return CMD_RET_FAILURE;
389
390         mmc_dev = mmc_get_dev(curr_device);
391         if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
392                 print_part(mmc_dev);
393                 return CMD_RET_SUCCESS;
394         }
395
396         puts("get mmc type error!\n");
397         return CMD_RET_FAILURE;
398 }
399 static int do_mmc_dev(cmd_tbl_t *cmdtp, int flag,
400                       int argc, char * const argv[])
401 {
402         int dev, part = 0, ret;
403         struct mmc *mmc;
404
405         if (argc == 1) {
406                 dev = curr_device;
407         } else if (argc == 2) {
408                 dev = simple_strtoul(argv[1], NULL, 10);
409         } else if (argc == 3) {
410                 dev = (int)simple_strtoul(argv[1], NULL, 10);
411                 part = (int)simple_strtoul(argv[2], NULL, 10);
412                 if (part > PART_ACCESS_MASK) {
413                         printf("#part_num shouldn't be larger than %d\n",
414                                PART_ACCESS_MASK);
415                         return CMD_RET_FAILURE;
416                 }
417         } else {
418                 return CMD_RET_USAGE;
419         }
420
421         mmc = init_mmc_device(dev, true);
422         if (!mmc)
423                 return CMD_RET_FAILURE;
424
425         ret = mmc_select_hwpart(dev, part);
426         printf("switch to partitions #%d, %s\n",
427                part, (!ret) ? "OK" : "ERROR");
428         if (ret)
429                 return 1;
430
431         curr_device = dev;
432         if (mmc->part_config == MMCPART_NOAVAILABLE)
433                 printf("mmc%d is current device\n", curr_device);
434         else
435                 printf("mmc%d(part %d) is current device\n",
436                        curr_device, mmc->part_num);
437
438         return CMD_RET_SUCCESS;
439 }
440 static int do_mmc_list(cmd_tbl_t *cmdtp, int flag,
441                        int argc, char * const argv[])
442 {
443         print_mmc_devices('\n');
444         return CMD_RET_SUCCESS;
445 }
446 #ifdef CONFIG_SUPPORT_EMMC_BOOT
447 static int do_mmc_bootbus(cmd_tbl_t *cmdtp, int flag,
448                           int argc, char * const argv[])
449 {
450         int dev;
451         struct mmc *mmc;
452         u8 width, reset, mode;
453
454         if (argc != 5)
455                 return CMD_RET_USAGE;
456         dev = simple_strtoul(argv[1], NULL, 10);
457         width = simple_strtoul(argv[2], NULL, 10);
458         reset = simple_strtoul(argv[3], NULL, 10);
459         mode = simple_strtoul(argv[4], NULL, 10);
460
461         mmc = init_mmc_device(dev, false);
462         if (!mmc)
463                 return CMD_RET_FAILURE;
464
465         if (IS_SD(mmc)) {
466                 puts("BOOT_BUS_WIDTH only exists on eMMC\n");
467                 return CMD_RET_FAILURE;
468         }
469
470         /* acknowledge to be sent during boot operation */
471         return mmc_set_boot_bus_width(mmc, width, reset, mode);
472 }
473 static int do_mmc_boot_resize(cmd_tbl_t *cmdtp, int flag,
474                               int argc, char * const argv[])
475 {
476         int dev;
477         struct mmc *mmc;
478         u32 bootsize, rpmbsize;
479
480         if (argc != 4)
481                 return CMD_RET_USAGE;
482         dev = simple_strtoul(argv[1], NULL, 10);
483         bootsize = simple_strtoul(argv[2], NULL, 10);
484         rpmbsize = simple_strtoul(argv[3], NULL, 10);
485
486         mmc = init_mmc_device(dev, false);
487         if (!mmc)
488                 return CMD_RET_FAILURE;
489
490         if (IS_SD(mmc)) {
491                 printf("It is not a EMMC device\n");
492                 return CMD_RET_FAILURE;
493         }
494
495         if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) {
496                 printf("EMMC boot partition Size change Failed.\n");
497                 return CMD_RET_FAILURE;
498         }
499
500         printf("EMMC boot partition Size %d MB\n", bootsize);
501         printf("EMMC RPMB partition Size %d MB\n", rpmbsize);
502         return CMD_RET_SUCCESS;
503 }
504 static int do_mmc_partconf(cmd_tbl_t *cmdtp, int flag,
505                            int argc, char * const argv[])
506 {
507         int dev;
508         struct mmc *mmc;
509         u8 ack, part_num, access;
510
511         if (argc != 5)
512                 return CMD_RET_USAGE;
513
514         dev = simple_strtoul(argv[1], NULL, 10);
515         ack = simple_strtoul(argv[2], NULL, 10);
516         part_num = simple_strtoul(argv[3], NULL, 10);
517         access = simple_strtoul(argv[4], NULL, 10);
518
519         mmc = init_mmc_device(dev, false);
520         if (!mmc)
521                 return CMD_RET_FAILURE;
522
523         if (IS_SD(mmc)) {
524                 puts("PARTITION_CONFIG only exists on eMMC\n");
525                 return CMD_RET_FAILURE;
526         }
527
528         /* acknowledge to be sent during boot operation */
529         return mmc_set_part_conf(mmc, ack, part_num, access);
530 }
531 static int do_mmc_rst_func(cmd_tbl_t *cmdtp, int flag,
532                            int argc, char * const argv[])
533 {
534         int dev;
535         struct mmc *mmc;
536         u8 enable;
537
538         /*
539          * Set the RST_n_ENABLE bit of RST_n_FUNCTION
540          * The only valid values are 0x0, 0x1 and 0x2 and writing
541          * a value of 0x1 or 0x2 sets the value permanently.
542          */
543         if (argc != 3)
544                 return CMD_RET_USAGE;
545
546         dev = simple_strtoul(argv[1], NULL, 10);
547         enable = simple_strtoul(argv[2], NULL, 10);
548
549         if (enable > 2 || enable < 0) {
550                 puts("Invalid RST_n_ENABLE value\n");
551                 return CMD_RET_USAGE;
552         }
553
554         mmc = init_mmc_device(dev, false);
555         if (!mmc)
556                 return CMD_RET_FAILURE;
557
558         if (IS_SD(mmc)) {
559                 puts("RST_n_FUNCTION only exists on eMMC\n");
560                 return CMD_RET_FAILURE;
561         }
562
563         return mmc_set_rst_n_function(mmc, enable);
564 }
565 #endif
566 static int do_mmc_setdsr(cmd_tbl_t *cmdtp, int flag,
567                          int argc, char * const argv[])
568 {
569         struct mmc *mmc;
570         u32 val;
571         int ret;
572
573         if (argc != 2)
574                 return CMD_RET_USAGE;
575         val = simple_strtoul(argv[2], NULL, 16);
576
577         mmc = find_mmc_device(curr_device);
578         if (!mmc) {
579                 printf("no mmc device at slot %x\n", curr_device);
580                 return CMD_RET_FAILURE;
581         }
582         ret = mmc_set_dsr(mmc, val);
583         printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR");
584         if (!ret) {
585                 mmc->has_init = 0;
586                 if (mmc_init(mmc))
587                         return CMD_RET_FAILURE;
588                 else
589                         return CMD_RET_SUCCESS;
590         }
591         return ret;
592 }
593
594 static cmd_tbl_t cmd_mmc[] = {
595         U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
596         U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
597         U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""),
598         U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""),
599         U_BOOT_CMD_MKENT(rescan, 1, 1, do_mmc_rescan, "", ""),
600         U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""),
601         U_BOOT_CMD_MKENT(dev, 3, 0, do_mmc_dev, "", ""),
602         U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""),
603 #ifdef CONFIG_SUPPORT_EMMC_BOOT
604         U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""),
605         U_BOOT_CMD_MKENT(bootpart-resize, 3, 0, do_mmc_boot_resize, "", ""),
606         U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""),
607         U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""),
608 #endif
609 #ifdef CONFIG_SUPPORT_EMMC_RPMB
610         U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""),
611 #endif
612         U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""),
613 };
614
615 static int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
616 {
617         cmd_tbl_t *cp;
618
619         cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
620
621         /* Drop the mmc command */
622         argc--;
623         argv++;
624
625         if (cp == NULL || argc > cp->maxargs)
626                 return CMD_RET_USAGE;
627         if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
628                 return CMD_RET_SUCCESS;
629
630         if (curr_device < 0) {
631                 if (get_mmc_num() > 0) {
632                         curr_device = 0;
633                 } else {
634                         puts("No MMC device available\n");
635                         return CMD_RET_FAILURE;
636                 }
637         }
638         return cp->cmd(cmdtp, flag, argc, argv);
639 }
640
641 U_BOOT_CMD(
642         mmc, 7, 1, do_mmcops,
643         "MMC sub system",
644         "info - display info of the current MMC device\n"
645         "mmc read addr blk# cnt\n"
646         "mmc write addr blk# cnt\n"
647         "mmc erase blk# cnt\n"
648         "mmc rescan\n"
649         "mmc part - lists available partition on current mmc device\n"
650         "mmc dev [dev] [part] - show or set current mmc device [partition]\n"
651         "mmc list - lists available devices\n"
652 #ifdef CONFIG_SUPPORT_EMMC_BOOT
653         "mmc bootbus dev boot_bus_width reset_boot_bus_width boot_mode\n"
654         " - Set the BOOT_BUS_WIDTH field of the specified device\n"
655         "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n"
656         " - Change sizes of boot and RPMB partitions of specified device\n"
657         "mmc partconf dev boot_ack boot_partition partition_access\n"
658         " - Change the bits of the PARTITION_CONFIG field of the specified device\n"
659         "mmc rst-function dev value\n"
660         " - Change the RST_n_FUNCTION field of the specified device\n"
661         "   WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n"
662 #endif
663 #ifdef CONFIG_SUPPORT_EMMC_RPMB
664         "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n"
665         "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n"
666         "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n"
667         "mmc rpmb counter - read the value of the write counter\n"
668 #endif
669         "mmc setdsr <value> - set DSR register value\n"
670         );
671
672 /* Old command kept for compatibility. Same as 'mmc info' */
673 U_BOOT_CMD(
674         mmcinfo, 1, 0, do_mmcinfo,
675         "display MMC info",
676         "- display info of the current MMC device"
677 );
678
679 #endif /* !CONFIG_GENERIC_MMC */