cmd_mmc: add force_init parameter to init_mmc_device()
[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 = find_mmc_device(curr_device);
375         if (!mmc) {
376                 printf("no mmc device at slot %x\n", curr_device);
377                 return CMD_RET_FAILURE;
378         }
379
380         mmc->has_init = 0;
381
382         if (mmc_init(mmc))
383                 return CMD_RET_FAILURE;
384         return CMD_RET_SUCCESS;
385 }
386 static int do_mmc_part(cmd_tbl_t *cmdtp, int flag,
387                        int argc, char * const argv[])
388 {
389         block_dev_desc_t *mmc_dev;
390         struct mmc *mmc;
391
392         mmc = init_mmc_device(curr_device, false);
393         if (!mmc)
394                 return CMD_RET_FAILURE;
395
396         mmc_dev = mmc_get_dev(curr_device);
397         if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
398                 print_part(mmc_dev);
399                 return CMD_RET_SUCCESS;
400         }
401
402         puts("get mmc type error!\n");
403         return CMD_RET_FAILURE;
404 }
405 static int do_mmc_dev(cmd_tbl_t *cmdtp, int flag,
406                       int argc, char * const argv[])
407 {
408         int dev, part = 0, ret;
409         struct mmc *mmc;
410
411         if (argc == 1) {
412                 dev = curr_device;
413         } else if (argc == 2) {
414                 dev = simple_strtoul(argv[1], NULL, 10);
415         } else if (argc == 3) {
416                 dev = (int)simple_strtoul(argv[1], NULL, 10);
417                 part = (int)simple_strtoul(argv[2], NULL, 10);
418                 if (part > PART_ACCESS_MASK) {
419                         printf("#part_num shouldn't be larger than %d\n",
420                                PART_ACCESS_MASK);
421                         return CMD_RET_FAILURE;
422                 }
423         } else {
424                 return CMD_RET_USAGE;
425         }
426
427         mmc = init_mmc_device(dev, false);
428         if (!mmc)
429                 return CMD_RET_FAILURE;
430
431         ret = mmc_select_hwpart(dev, part);
432         printf("switch to partitions #%d, %s\n",
433                part, (!ret) ? "OK" : "ERROR");
434         if (ret)
435                 return 1;
436
437         curr_device = dev;
438         if (mmc->part_config == MMCPART_NOAVAILABLE)
439                 printf("mmc%d is current device\n", curr_device);
440         else
441                 printf("mmc%d(part %d) is current device\n",
442                        curr_device, mmc->part_num);
443
444         return CMD_RET_SUCCESS;
445 }
446 static int do_mmc_list(cmd_tbl_t *cmdtp, int flag,
447                        int argc, char * const argv[])
448 {
449         print_mmc_devices('\n');
450         return CMD_RET_SUCCESS;
451 }
452 #ifdef CONFIG_SUPPORT_EMMC_BOOT
453 static int do_mmc_bootbus(cmd_tbl_t *cmdtp, int flag,
454                           int argc, char * const argv[])
455 {
456         int dev;
457         struct mmc *mmc;
458         u8 width, reset, mode;
459
460         if (argc != 5)
461                 return CMD_RET_USAGE;
462         dev = simple_strtoul(argv[1], NULL, 10);
463         width = simple_strtoul(argv[2], NULL, 10);
464         reset = simple_strtoul(argv[3], NULL, 10);
465         mode = simple_strtoul(argv[4], NULL, 10);
466
467         mmc = init_mmc_device(dev, false);
468         if (!mmc)
469                 return CMD_RET_FAILURE;
470
471         if (IS_SD(mmc)) {
472                 puts("BOOT_BUS_WIDTH only exists on eMMC\n");
473                 return CMD_RET_FAILURE;
474         }
475
476         /* acknowledge to be sent during boot operation */
477         return mmc_set_boot_bus_width(mmc, width, reset, mode);
478 }
479 static int do_mmc_boot_resize(cmd_tbl_t *cmdtp, int flag,
480                               int argc, char * const argv[])
481 {
482         int dev;
483         struct mmc *mmc;
484         u32 bootsize, rpmbsize;
485
486         if (argc != 4)
487                 return CMD_RET_USAGE;
488         dev = simple_strtoul(argv[1], NULL, 10);
489         bootsize = simple_strtoul(argv[2], NULL, 10);
490         rpmbsize = simple_strtoul(argv[3], NULL, 10);
491
492         mmc = init_mmc_device(dev, false);
493         if (!mmc)
494                 return CMD_RET_FAILURE;
495
496         if (IS_SD(mmc)) {
497                 printf("It is not a EMMC device\n");
498                 return CMD_RET_FAILURE;
499         }
500
501         if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) {
502                 printf("EMMC boot partition Size change Failed.\n");
503                 return CMD_RET_FAILURE;
504         }
505
506         printf("EMMC boot partition Size %d MB\n", bootsize);
507         printf("EMMC RPMB partition Size %d MB\n", rpmbsize);
508         return CMD_RET_SUCCESS;
509 }
510 static int do_mmc_partconf(cmd_tbl_t *cmdtp, int flag,
511                            int argc, char * const argv[])
512 {
513         int dev;
514         struct mmc *mmc;
515         u8 ack, part_num, access;
516
517         if (argc != 5)
518                 return CMD_RET_USAGE;
519
520         dev = simple_strtoul(argv[1], NULL, 10);
521         ack = simple_strtoul(argv[2], NULL, 10);
522         part_num = simple_strtoul(argv[3], NULL, 10);
523         access = simple_strtoul(argv[4], NULL, 10);
524
525         mmc = init_mmc_device(dev, false);
526         if (!mmc)
527                 return CMD_RET_FAILURE;
528
529         if (IS_SD(mmc)) {
530                 puts("PARTITION_CONFIG only exists on eMMC\n");
531                 return CMD_RET_FAILURE;
532         }
533
534         /* acknowledge to be sent during boot operation */
535         return mmc_set_part_conf(mmc, ack, part_num, access);
536 }
537 static int do_mmc_rst_func(cmd_tbl_t *cmdtp, int flag,
538                            int argc, char * const argv[])
539 {
540         int dev;
541         struct mmc *mmc;
542         u8 enable;
543
544         /*
545          * Set the RST_n_ENABLE bit of RST_n_FUNCTION
546          * The only valid values are 0x0, 0x1 and 0x2 and writing
547          * a value of 0x1 or 0x2 sets the value permanently.
548          */
549         if (argc != 3)
550                 return CMD_RET_USAGE;
551
552         dev = simple_strtoul(argv[1], NULL, 10);
553         enable = simple_strtoul(argv[2], NULL, 10);
554
555         if (enable > 2 || enable < 0) {
556                 puts("Invalid RST_n_ENABLE value\n");
557                 return CMD_RET_USAGE;
558         }
559
560         mmc = init_mmc_device(dev, false);
561         if (!mmc)
562                 return CMD_RET_FAILURE;
563
564         if (IS_SD(mmc)) {
565                 puts("RST_n_FUNCTION only exists on eMMC\n");
566                 return CMD_RET_FAILURE;
567         }
568
569         return mmc_set_rst_n_function(mmc, enable);
570 }
571 #endif
572 static int do_mmc_setdsr(cmd_tbl_t *cmdtp, int flag,
573                          int argc, char * const argv[])
574 {
575         struct mmc *mmc;
576         u32 val;
577         int ret;
578
579         if (argc != 2)
580                 return CMD_RET_USAGE;
581         val = simple_strtoul(argv[2], NULL, 16);
582
583         mmc = find_mmc_device(curr_device);
584         if (!mmc) {
585                 printf("no mmc device at slot %x\n", curr_device);
586                 return CMD_RET_FAILURE;
587         }
588         ret = mmc_set_dsr(mmc, val);
589         printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR");
590         if (!ret) {
591                 mmc->has_init = 0;
592                 if (mmc_init(mmc))
593                         return CMD_RET_FAILURE;
594                 else
595                         return CMD_RET_SUCCESS;
596         }
597         return ret;
598 }
599
600 static cmd_tbl_t cmd_mmc[] = {
601         U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
602         U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
603         U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""),
604         U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""),
605         U_BOOT_CMD_MKENT(rescan, 1, 1, do_mmc_rescan, "", ""),
606         U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""),
607         U_BOOT_CMD_MKENT(dev, 3, 0, do_mmc_dev, "", ""),
608         U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""),
609 #ifdef CONFIG_SUPPORT_EMMC_BOOT
610         U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""),
611         U_BOOT_CMD_MKENT(bootpart-resize, 3, 0, do_mmc_boot_resize, "", ""),
612         U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""),
613         U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""),
614 #endif
615 #ifdef CONFIG_SUPPORT_EMMC_RPMB
616         U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""),
617 #endif
618         U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""),
619 };
620
621 static int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
622 {
623         cmd_tbl_t *cp;
624
625         cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
626
627         /* Drop the mmc command */
628         argc--;
629         argv++;
630
631         if (cp == NULL || argc > cp->maxargs)
632                 return CMD_RET_USAGE;
633         if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
634                 return CMD_RET_SUCCESS;
635
636         if (curr_device < 0) {
637                 if (get_mmc_num() > 0) {
638                         curr_device = 0;
639                 } else {
640                         puts("No MMC device available\n");
641                         return CMD_RET_FAILURE;
642                 }
643         }
644         return cp->cmd(cmdtp, flag, argc, argv);
645 }
646
647 U_BOOT_CMD(
648         mmc, 7, 1, do_mmcops,
649         "MMC sub system",
650         "info - display info of the current MMC device\n"
651         "mmc read addr blk# cnt\n"
652         "mmc write addr blk# cnt\n"
653         "mmc erase blk# cnt\n"
654         "mmc rescan\n"
655         "mmc part - lists available partition on current mmc device\n"
656         "mmc dev [dev] [part] - show or set current mmc device [partition]\n"
657         "mmc list - lists available devices\n"
658 #ifdef CONFIG_SUPPORT_EMMC_BOOT
659         "mmc bootbus dev boot_bus_width reset_boot_bus_width boot_mode\n"
660         " - Set the BOOT_BUS_WIDTH field of the specified device\n"
661         "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n"
662         " - Change sizes of boot and RPMB partitions of specified device\n"
663         "mmc partconf dev boot_ack boot_partition partition_access\n"
664         " - Change the bits of the PARTITION_CONFIG field of the specified device\n"
665         "mmc rst-function dev value\n"
666         " - Change the RST_n_FUNCTION field of the specified device\n"
667         "   WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n"
668 #endif
669 #ifdef CONFIG_SUPPORT_EMMC_RPMB
670         "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n"
671         "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n"
672         "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n"
673         "mmc rpmb counter - read the value of the write counter\n"
674 #endif
675         "mmc setdsr <value> - set DSR register value\n"
676         );
677
678 /* Old command kept for compatibility. Same as 'mmc info' */
679 U_BOOT_CMD(
680         mmcinfo, 1, 0, do_mmcinfo,
681         "display MMC info",
682         "- display info of the current MMC device"
683 );
684
685 #endif /* !CONFIG_GENERIC_MMC */