1
2
3
4
5
6
7#include <common.h>
8#include <blk.h>
9#include <command.h>
10#include <console.h>
11#include <memalign.h>
12#include <mmc.h>
13#include <part.h>
14#include <sparse_format.h>
15#include <image-sparse.h>
16
17static int curr_device = -1;
18
19static void print_mmcinfo(struct mmc *mmc)
20{
21 int i;
22
23 printf("Device: %s\n", mmc->cfg->name);
24 printf("Manufacturer ID: %x\n", mmc->cid[0] >> 24);
25 printf("OEM: %x\n", (mmc->cid[0] >> 8) & 0xffff);
26 printf("Name: %c%c%c%c%c \n", mmc->cid[0] & 0xff,
27 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
28 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
29
30 printf("Bus Speed: %d\n", mmc->clock);
31#if CONFIG_IS_ENABLED(MMC_VERBOSE)
32 printf("Mode: %s\n", mmc_mode_name(mmc->selected_mode));
33 mmc_dump_capabilities("card capabilities", mmc->card_caps);
34 mmc_dump_capabilities("host capabilities", mmc->host_caps);
35#endif
36 printf("Rd Block Len: %d\n", mmc->read_bl_len);
37
38 printf("%s version %d.%d", IS_SD(mmc) ? "SD" : "MMC",
39 EXTRACT_SDMMC_MAJOR_VERSION(mmc->version),
40 EXTRACT_SDMMC_MINOR_VERSION(mmc->version));
41 if (EXTRACT_SDMMC_CHANGE_VERSION(mmc->version) != 0)
42 printf(".%d", EXTRACT_SDMMC_CHANGE_VERSION(mmc->version));
43 printf("\n");
44
45 printf("High Capacity: %s\n", mmc->high_capacity ? "Yes" : "No");
46 puts("Capacity: ");
47 print_size(mmc->capacity, "\n");
48
49 printf("Bus Width: %d-bit%s\n", mmc->bus_width,
50 mmc->ddr_mode ? " DDR" : "");
51
52#if CONFIG_IS_ENABLED(MMC_WRITE)
53 puts("Erase Group Size: ");
54 print_size(((u64)mmc->erase_grp_size) << 9, "\n");
55#endif
56
57 if (!IS_SD(mmc) && mmc->version >= MMC_VERSION_4_41) {
58 bool has_enh = (mmc->part_support & ENHNCD_SUPPORT) != 0;
59 bool usr_enh = has_enh && (mmc->part_attr & EXT_CSD_ENH_USR);
60 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
61 u8 wp;
62 int ret;
63
64#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
65 puts("HC WP Group Size: ");
66 print_size(((u64)mmc->hc_wp_grp_size) << 9, "\n");
67#endif
68
69 puts("User Capacity: ");
70 print_size(mmc->capacity_user, usr_enh ? " ENH" : "");
71 if (mmc->wr_rel_set & EXT_CSD_WR_DATA_REL_USR)
72 puts(" WRREL\n");
73 else
74 putc('\n');
75 if (usr_enh) {
76 puts("User Enhanced Start: ");
77 print_size(mmc->enh_user_start, "\n");
78 puts("User Enhanced Size: ");
79 print_size(mmc->enh_user_size, "\n");
80 }
81 puts("Boot Capacity: ");
82 print_size(mmc->capacity_boot, has_enh ? " ENH\n" : "\n");
83 puts("RPMB Capacity: ");
84 print_size(mmc->capacity_rpmb, has_enh ? " ENH\n" : "\n");
85
86 for (i = 0; i < ARRAY_SIZE(mmc->capacity_gp); i++) {
87 bool is_enh = has_enh &&
88 (mmc->part_attr & EXT_CSD_ENH_GP(i));
89 if (mmc->capacity_gp[i]) {
90 printf("GP%i Capacity: ", i+1);
91 print_size(mmc->capacity_gp[i],
92 is_enh ? " ENH" : "");
93 if (mmc->wr_rel_set & EXT_CSD_WR_DATA_REL_GP(i))
94 puts(" WRREL\n");
95 else
96 putc('\n');
97 }
98 }
99 ret = mmc_send_ext_csd(mmc, ext_csd);
100 if (ret)
101 return;
102 wp = ext_csd[EXT_CSD_BOOT_WP_STATUS];
103 for (i = 0; i < 2; ++i) {
104 printf("Boot area %d is ", i);
105 switch (wp & 3) {
106 case 0:
107 printf("not write protected\n");
108 break;
109 case 1:
110 printf("power on protected\n");
111 break;
112 case 2:
113 printf("permanently protected\n");
114 break;
115 default:
116 printf("in reserved protection state\n");
117 break;
118 }
119 wp >>= 2;
120 }
121 }
122}
123
124static struct mmc *__init_mmc_device(int dev, bool force_init,
125 enum bus_mode speed_mode)
126{
127 struct mmc *mmc;
128 mmc = find_mmc_device(dev);
129 if (!mmc) {
130 printf("no mmc device at slot %x\n", dev);
131 return NULL;
132 }
133
134 if (!mmc_getcd(mmc))
135 force_init = true;
136
137 if (force_init)
138 mmc->has_init = 0;
139
140 if (IS_ENABLED(CONFIG_MMC_SPEED_MODE_SET))
141 mmc->user_speed_mode = speed_mode;
142
143 if (mmc_init(mmc))
144 return NULL;
145
146#ifdef CONFIG_BLOCK_CACHE
147 struct blk_desc *bd = mmc_get_blk_desc(mmc);
148 blkcache_invalidate(bd->if_type, bd->devnum);
149#endif
150
151 return mmc;
152}
153
154static struct mmc *init_mmc_device(int dev, bool force_init)
155{
156 return __init_mmc_device(dev, force_init, MMC_MODES_END);
157}
158
159static int do_mmcinfo(struct cmd_tbl *cmdtp, int flag, int argc,
160 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 1;
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#if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
182static 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
194static int do_mmcrpmb_key(struct cmd_tbl *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 *)hextoul(argv[1], NULL);
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
213static int do_mmcrpmb_read(struct cmd_tbl *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 *)hextoul(argv[1], NULL);
226 blk = hextoul(argv[2], NULL);
227 cnt = hextoul(argv[3], NULL);
228
229 if (argc == 5)
230 key_addr = (void *)hextoul(argv[4], NULL);
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
242static int do_mmcrpmb_write(struct cmd_tbl *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 *)hextoul(argv[1], NULL);
255 blk = hextoul(argv[2], NULL);
256 cnt = hextoul(argv[3], NULL);
257 key_addr = (void *)hextoul(argv[4], NULL);
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
269static int do_mmcrpmb_counter(struct cmd_tbl *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
281static struct cmd_tbl 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
288static int do_mmcrpmb(struct cmd_tbl *cmdtp, int flag,
289 int argc, char *const argv[])
290{
291 struct cmd_tbl *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
299 argc--;
300 argv++;
301
302 if (cp == NULL || argc > cp->maxargs)
303 return CMD_RET_USAGE;
304 if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
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 an 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
320#ifndef CONFIG_BLK
321 original_part = mmc->block_dev.hwpart;
322#else
323 original_part = mmc_get_blk_desc(mmc)->hwpart;
324#endif
325 if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, MMC_PART_RPMB) !=
326 0)
327 return CMD_RET_FAILURE;
328 ret = cp->cmd(cmdtp, flag, argc, argv);
329
330
331 if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, original_part) !=
332 0)
333 return CMD_RET_FAILURE;
334 return ret;
335}
336#endif
337
338static int do_mmc_read(struct cmd_tbl *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 *)hextoul(argv[1], NULL);
349 blk = hextoul(argv[2], NULL);
350 cnt = hextoul(argv[3], NULL);
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 = blk_dread(mmc_get_blk_desc(mmc), blk, cnt, addr);
360 printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
361
362 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
363}
364
365#if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
366static lbaint_t mmc_sparse_write(struct sparse_storage *info, lbaint_t blk,
367 lbaint_t blkcnt, const void *buffer)
368{
369 struct blk_desc *dev_desc = info->priv;
370
371 return blk_dwrite(dev_desc, blk, blkcnt, buffer);
372}
373
374static lbaint_t mmc_sparse_reserve(struct sparse_storage *info,
375 lbaint_t blk, lbaint_t blkcnt)
376{
377 return blkcnt;
378}
379
380static int do_mmc_sparse_write(struct cmd_tbl *cmdtp, int flag,
381 int argc, char *const argv[])
382{
383 struct sparse_storage sparse;
384 struct blk_desc *dev_desc;
385 struct mmc *mmc;
386 char dest[11];
387 void *addr;
388 u32 blk;
389
390 if (argc != 3)
391 return CMD_RET_USAGE;
392
393 addr = (void *)hextoul(argv[1], NULL);
394 blk = hextoul(argv[2], NULL);
395
396 if (!is_sparse_image(addr)) {
397 printf("Not a sparse image\n");
398 return CMD_RET_FAILURE;
399 }
400
401 mmc = init_mmc_device(curr_device, false);
402 if (!mmc)
403 return CMD_RET_FAILURE;
404
405 printf("\nMMC Sparse write: dev # %d, block # %d ... ",
406 curr_device, blk);
407
408 if (mmc_getwp(mmc) == 1) {
409 printf("Error: card is write protected!\n");
410 return CMD_RET_FAILURE;
411 }
412
413 dev_desc = mmc_get_blk_desc(mmc);
414 sparse.priv = dev_desc;
415 sparse.blksz = 512;
416 sparse.start = blk;
417 sparse.size = dev_desc->lba - blk;
418 sparse.write = mmc_sparse_write;
419 sparse.reserve = mmc_sparse_reserve;
420 sparse.mssg = NULL;
421 sprintf(dest, "0x" LBAF, sparse.start * sparse.blksz);
422
423 if (write_sparse_image(&sparse, dest, addr, NULL))
424 return CMD_RET_FAILURE;
425 else
426 return CMD_RET_SUCCESS;
427}
428#endif
429
430#if CONFIG_IS_ENABLED(MMC_WRITE)
431static int do_mmc_write(struct cmd_tbl *cmdtp, int flag,
432 int argc, char *const argv[])
433{
434 struct mmc *mmc;
435 u32 blk, cnt, n;
436 void *addr;
437
438 if (argc != 4)
439 return CMD_RET_USAGE;
440
441 addr = (void *)hextoul(argv[1], NULL);
442 blk = hextoul(argv[2], NULL);
443 cnt = hextoul(argv[3], NULL);
444
445 mmc = init_mmc_device(curr_device, false);
446 if (!mmc)
447 return CMD_RET_FAILURE;
448
449 printf("\nMMC write: dev # %d, block # %d, count %d ... ",
450 curr_device, blk, cnt);
451
452 if (mmc_getwp(mmc) == 1) {
453 printf("Error: card is write protected!\n");
454 return CMD_RET_FAILURE;
455 }
456 n = blk_dwrite(mmc_get_blk_desc(mmc), blk, cnt, addr);
457 printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
458
459 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
460}
461
462static int do_mmc_erase(struct cmd_tbl *cmdtp, int flag,
463 int argc, char *const argv[])
464{
465 struct mmc *mmc;
466 u32 blk, cnt, n;
467
468 if (argc != 3)
469 return CMD_RET_USAGE;
470
471 blk = hextoul(argv[1], NULL);
472 cnt = hextoul(argv[2], NULL);
473
474 mmc = init_mmc_device(curr_device, false);
475 if (!mmc)
476 return CMD_RET_FAILURE;
477
478 printf("\nMMC erase: dev # %d, block # %d, count %d ... ",
479 curr_device, blk, cnt);
480
481 if (mmc_getwp(mmc) == 1) {
482 printf("Error: card is write protected!\n");
483 return CMD_RET_FAILURE;
484 }
485 n = blk_derase(mmc_get_blk_desc(mmc), blk, cnt);
486 printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR");
487
488 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
489}
490#endif
491
492static int do_mmc_rescan(struct cmd_tbl *cmdtp, int flag,
493 int argc, char *const argv[])
494{
495 struct mmc *mmc;
496 enum bus_mode speed_mode = MMC_MODES_END;
497
498 if (argc == 1) {
499 mmc = init_mmc_device(curr_device, true);
500 } else if (argc == 2) {
501 speed_mode = (int)dectoul(argv[1], NULL);
502 mmc = __init_mmc_device(curr_device, true, speed_mode);
503 } else {
504 return CMD_RET_USAGE;
505 }
506
507 if (!mmc)
508 return CMD_RET_FAILURE;
509
510 return CMD_RET_SUCCESS;
511}
512
513static int do_mmc_part(struct cmd_tbl *cmdtp, int flag,
514 int argc, char *const argv[])
515{
516 struct blk_desc *mmc_dev;
517 struct mmc *mmc;
518
519 mmc = init_mmc_device(curr_device, false);
520 if (!mmc)
521 return CMD_RET_FAILURE;
522
523 mmc_dev = blk_get_devnum_by_type(IF_TYPE_MMC, curr_device);
524 if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
525 part_print(mmc_dev);
526 return CMD_RET_SUCCESS;
527 }
528
529 puts("get mmc type error!\n");
530 return CMD_RET_FAILURE;
531}
532
533static int do_mmc_dev(struct cmd_tbl *cmdtp, int flag,
534 int argc, char *const argv[])
535{
536 int dev, part = 0, ret;
537 struct mmc *mmc;
538 enum bus_mode speed_mode = MMC_MODES_END;
539
540 if (argc == 1) {
541 dev = curr_device;
542 mmc = init_mmc_device(dev, true);
543 } else if (argc == 2) {
544 dev = (int)dectoul(argv[1], NULL);
545 mmc = init_mmc_device(dev, true);
546 } else if (argc == 3) {
547 dev = (int)dectoul(argv[1], NULL);
548 part = (int)dectoul(argv[2], NULL);
549 if (part > PART_ACCESS_MASK) {
550 printf("#part_num shouldn't be larger than %d\n",
551 PART_ACCESS_MASK);
552 return CMD_RET_FAILURE;
553 }
554 mmc = init_mmc_device(dev, true);
555 } else if (argc == 4) {
556 dev = (int)dectoul(argv[1], NULL);
557 part = (int)dectoul(argv[2], NULL);
558 if (part > PART_ACCESS_MASK) {
559 printf("#part_num shouldn't be larger than %d\n",
560 PART_ACCESS_MASK);
561 return CMD_RET_FAILURE;
562 }
563 speed_mode = (int)dectoul(argv[3], NULL);
564 mmc = __init_mmc_device(dev, true, speed_mode);
565 } else {
566 return CMD_RET_USAGE;
567 }
568
569 if (!mmc)
570 return CMD_RET_FAILURE;
571
572 ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
573 printf("switch to partitions #%d, %s\n",
574 part, (!ret) ? "OK" : "ERROR");
575 if (ret)
576 return 1;
577
578 curr_device = dev;
579 if (mmc->part_config == MMCPART_NOAVAILABLE)
580 printf("mmc%d is current device\n", curr_device);
581 else
582 printf("mmc%d(part %d) is current device\n",
583 curr_device, mmc_get_blk_desc(mmc)->hwpart);
584
585 return CMD_RET_SUCCESS;
586}
587
588static int do_mmc_list(struct cmd_tbl *cmdtp, int flag,
589 int argc, char *const argv[])
590{
591 print_mmc_devices('\n');
592 return CMD_RET_SUCCESS;
593}
594
595#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
596static int parse_hwpart_user(struct mmc_hwpart_conf *pconf,
597 int argc, char *const argv[])
598{
599 int i = 0;
600
601 memset(&pconf->user, 0, sizeof(pconf->user));
602
603 while (i < argc) {
604 if (!strcmp(argv[i], "enh")) {
605 if (i + 2 >= argc)
606 return -1;
607 pconf->user.enh_start =
608 dectoul(argv[i + 1], NULL);
609 pconf->user.enh_size =
610 dectoul(argv[i + 2], NULL);
611 i += 3;
612 } else if (!strcmp(argv[i], "wrrel")) {
613 if (i + 1 >= argc)
614 return -1;
615 pconf->user.wr_rel_change = 1;
616 if (!strcmp(argv[i+1], "on"))
617 pconf->user.wr_rel_set = 1;
618 else if (!strcmp(argv[i+1], "off"))
619 pconf->user.wr_rel_set = 0;
620 else
621 return -1;
622 i += 2;
623 } else {
624 break;
625 }
626 }
627 return i;
628}
629
630static int parse_hwpart_gp(struct mmc_hwpart_conf *pconf, int pidx,
631 int argc, char *const argv[])
632{
633 int i;
634
635 memset(&pconf->gp_part[pidx], 0, sizeof(pconf->gp_part[pidx]));
636
637 if (1 >= argc)
638 return -1;
639 pconf->gp_part[pidx].size = dectoul(argv[0], NULL);
640
641 i = 1;
642 while (i < argc) {
643 if (!strcmp(argv[i], "enh")) {
644 pconf->gp_part[pidx].enhanced = 1;
645 i += 1;
646 } else if (!strcmp(argv[i], "wrrel")) {
647 if (i + 1 >= argc)
648 return -1;
649 pconf->gp_part[pidx].wr_rel_change = 1;
650 if (!strcmp(argv[i+1], "on"))
651 pconf->gp_part[pidx].wr_rel_set = 1;
652 else if (!strcmp(argv[i+1], "off"))
653 pconf->gp_part[pidx].wr_rel_set = 0;
654 else
655 return -1;
656 i += 2;
657 } else {
658 break;
659 }
660 }
661 return i;
662}
663
664static int do_mmc_hwpartition(struct cmd_tbl *cmdtp, int flag,
665 int argc, char *const argv[])
666{
667 struct mmc *mmc;
668 struct mmc_hwpart_conf pconf = { };
669 enum mmc_hwpart_conf_mode mode = MMC_HWPART_CONF_CHECK;
670 int i, r, pidx;
671
672 mmc = init_mmc_device(curr_device, false);
673 if (!mmc)
674 return CMD_RET_FAILURE;
675
676 if (argc < 1)
677 return CMD_RET_USAGE;
678 i = 1;
679 while (i < argc) {
680 if (!strcmp(argv[i], "user")) {
681 i++;
682 r = parse_hwpart_user(&pconf, argc-i, &argv[i]);
683 if (r < 0)
684 return CMD_RET_USAGE;
685 i += r;
686 } else if (!strncmp(argv[i], "gp", 2) &&
687 strlen(argv[i]) == 3 &&
688 argv[i][2] >= '1' && argv[i][2] <= '4') {
689 pidx = argv[i][2] - '1';
690 i++;
691 r = parse_hwpart_gp(&pconf, pidx, argc-i, &argv[i]);
692 if (r < 0)
693 return CMD_RET_USAGE;
694 i += r;
695 } else if (!strcmp(argv[i], "check")) {
696 mode = MMC_HWPART_CONF_CHECK;
697 i++;
698 } else if (!strcmp(argv[i], "set")) {
699 mode = MMC_HWPART_CONF_SET;
700 i++;
701 } else if (!strcmp(argv[i], "complete")) {
702 mode = MMC_HWPART_CONF_COMPLETE;
703 i++;
704 } else {
705 return CMD_RET_USAGE;
706 }
707 }
708
709 puts("Partition configuration:\n");
710 if (pconf.user.enh_size) {
711 puts("\tUser Enhanced Start: ");
712 print_size(((u64)pconf.user.enh_start) << 9, "\n");
713 puts("\tUser Enhanced Size: ");
714 print_size(((u64)pconf.user.enh_size) << 9, "\n");
715 } else {
716 puts("\tNo enhanced user data area\n");
717 }
718 if (pconf.user.wr_rel_change)
719 printf("\tUser partition write reliability: %s\n",
720 pconf.user.wr_rel_set ? "on" : "off");
721 for (pidx = 0; pidx < 4; pidx++) {
722 if (pconf.gp_part[pidx].size) {
723 printf("\tGP%i Capacity: ", pidx+1);
724 print_size(((u64)pconf.gp_part[pidx].size) << 9,
725 pconf.gp_part[pidx].enhanced ?
726 " ENH\n" : "\n");
727 } else {
728 printf("\tNo GP%i partition\n", pidx+1);
729 }
730 if (pconf.gp_part[pidx].wr_rel_change)
731 printf("\tGP%i write reliability: %s\n", pidx+1,
732 pconf.gp_part[pidx].wr_rel_set ? "on" : "off");
733 }
734
735 if (!mmc_hwpart_config(mmc, &pconf, mode)) {
736 if (mode == MMC_HWPART_CONF_COMPLETE)
737 puts("Partitioning successful, "
738 "power-cycle to make effective\n");
739 return CMD_RET_SUCCESS;
740 } else {
741 puts("Failed!\n");
742 return CMD_RET_FAILURE;
743 }
744}
745#endif
746
747#ifdef CONFIG_SUPPORT_EMMC_BOOT
748static int do_mmc_bootbus(struct cmd_tbl *cmdtp, int flag,
749 int argc, char *const argv[])
750{
751 int dev;
752 struct mmc *mmc;
753 u8 width, reset, mode;
754
755 if (argc != 5)
756 return CMD_RET_USAGE;
757 dev = dectoul(argv[1], NULL);
758 width = dectoul(argv[2], NULL);
759 reset = dectoul(argv[3], NULL);
760 mode = dectoul(argv[4], NULL);
761
762 mmc = init_mmc_device(dev, false);
763 if (!mmc)
764 return CMD_RET_FAILURE;
765
766 if (IS_SD(mmc)) {
767 puts("BOOT_BUS_WIDTH only exists on eMMC\n");
768 return CMD_RET_FAILURE;
769 }
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786 if (width >= 0x3) {
787 printf("boot_bus_width %d is invalid\n", width);
788 return CMD_RET_FAILURE;
789 }
790
791 if (reset >= 0x2) {
792 printf("reset_boot_bus_width %d is invalid\n", reset);
793 return CMD_RET_FAILURE;
794 }
795
796 if (mode >= 0x3) {
797 printf("reset_boot_bus_width %d is invalid\n", mode);
798 return CMD_RET_FAILURE;
799 }
800
801
802 if (mmc_set_boot_bus_width(mmc, width, reset, mode)) {
803 puts("BOOT_BUS_WIDTH is failed to change.\n");
804 return CMD_RET_FAILURE;
805 }
806
807 printf("Set to BOOT_BUS_WIDTH = 0x%x, RESET = 0x%x, BOOT_MODE = 0x%x\n",
808 width, reset, mode);
809 return CMD_RET_SUCCESS;
810}
811
812static int do_mmc_boot_resize(struct cmd_tbl *cmdtp, int flag,
813 int argc, char *const argv[])
814{
815 int dev;
816 struct mmc *mmc;
817 u32 bootsize, rpmbsize;
818
819 if (argc != 4)
820 return CMD_RET_USAGE;
821 dev = dectoul(argv[1], NULL);
822 bootsize = dectoul(argv[2], NULL);
823 rpmbsize = dectoul(argv[3], NULL);
824
825 mmc = init_mmc_device(dev, false);
826 if (!mmc)
827 return CMD_RET_FAILURE;
828
829 if (IS_SD(mmc)) {
830 printf("It is not an eMMC device\n");
831 return CMD_RET_FAILURE;
832 }
833
834 if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) {
835 printf("EMMC boot partition Size change Failed.\n");
836 return CMD_RET_FAILURE;
837 }
838
839 printf("EMMC boot partition Size %d MB\n", bootsize);
840 printf("EMMC RPMB partition Size %d MB\n", rpmbsize);
841 return CMD_RET_SUCCESS;
842}
843
844static int mmc_partconf_print(struct mmc *mmc, const char *varname)
845{
846 u8 ack, access, part;
847
848 if (mmc->part_config == MMCPART_NOAVAILABLE) {
849 printf("No part_config info for ver. 0x%x\n", mmc->version);
850 return CMD_RET_FAILURE;
851 }
852
853 access = EXT_CSD_EXTRACT_PARTITION_ACCESS(mmc->part_config);
854 ack = EXT_CSD_EXTRACT_BOOT_ACK(mmc->part_config);
855 part = EXT_CSD_EXTRACT_BOOT_PART(mmc->part_config);
856
857 if(varname)
858 env_set_hex(varname, part);
859
860 printf("EXT_CSD[179], PARTITION_CONFIG:\n"
861 "BOOT_ACK: 0x%x\n"
862 "BOOT_PARTITION_ENABLE: 0x%x\n"
863 "PARTITION_ACCESS: 0x%x\n", ack, part, access);
864
865 return CMD_RET_SUCCESS;
866}
867
868static int do_mmc_partconf(struct cmd_tbl *cmdtp, int flag,
869 int argc, char *const argv[])
870{
871 int dev;
872 struct mmc *mmc;
873 u8 ack, part_num, access;
874
875 if (argc != 2 && argc != 3 && argc != 5)
876 return CMD_RET_USAGE;
877
878 dev = dectoul(argv[1], NULL);
879
880 mmc = init_mmc_device(dev, false);
881 if (!mmc)
882 return CMD_RET_FAILURE;
883
884 if (IS_SD(mmc)) {
885 puts("PARTITION_CONFIG only exists on eMMC\n");
886 return CMD_RET_FAILURE;
887 }
888
889 if (argc == 2 || argc == 3)
890 return mmc_partconf_print(mmc, argc == 3 ? argv[2] : NULL);
891
892 ack = dectoul(argv[2], NULL);
893 part_num = dectoul(argv[3], NULL);
894 access = dectoul(argv[4], NULL);
895
896
897 return mmc_set_part_conf(mmc, ack, part_num, access);
898}
899
900static int do_mmc_rst_func(struct cmd_tbl *cmdtp, int flag,
901 int argc, char *const argv[])
902{
903 int dev;
904 struct mmc *mmc;
905 u8 enable;
906
907
908
909
910
911
912 if (argc != 3)
913 return CMD_RET_USAGE;
914
915 dev = dectoul(argv[1], NULL);
916 enable = dectoul(argv[2], NULL);
917
918 if (enable > 2) {
919 puts("Invalid RST_n_ENABLE value\n");
920 return CMD_RET_USAGE;
921 }
922
923 mmc = init_mmc_device(dev, false);
924 if (!mmc)
925 return CMD_RET_FAILURE;
926
927 if (IS_SD(mmc)) {
928 puts("RST_n_FUNCTION only exists on eMMC\n");
929 return CMD_RET_FAILURE;
930 }
931
932 return mmc_set_rst_n_function(mmc, enable);
933}
934#endif
935static int do_mmc_setdsr(struct cmd_tbl *cmdtp, int flag,
936 int argc, char *const argv[])
937{
938 struct mmc *mmc;
939 u32 val;
940 int ret;
941
942 if (argc != 2)
943 return CMD_RET_USAGE;
944 val = hextoul(argv[1], NULL);
945
946 mmc = find_mmc_device(curr_device);
947 if (!mmc) {
948 printf("no mmc device at slot %x\n", curr_device);
949 return CMD_RET_FAILURE;
950 }
951 ret = mmc_set_dsr(mmc, val);
952 printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR");
953 if (!ret) {
954 mmc->has_init = 0;
955 if (mmc_init(mmc))
956 return CMD_RET_FAILURE;
957 else
958 return CMD_RET_SUCCESS;
959 }
960 return ret;
961}
962
963#ifdef CONFIG_CMD_BKOPS_ENABLE
964static int do_mmc_bkops_enable(struct cmd_tbl *cmdtp, int flag,
965 int argc, char *const argv[])
966{
967 int dev;
968 struct mmc *mmc;
969
970 if (argc != 2)
971 return CMD_RET_USAGE;
972
973 dev = dectoul(argv[1], NULL);
974
975 mmc = init_mmc_device(dev, false);
976 if (!mmc)
977 return CMD_RET_FAILURE;
978
979 if (IS_SD(mmc)) {
980 puts("BKOPS_EN only exists on eMMC\n");
981 return CMD_RET_FAILURE;
982 }
983
984 return mmc_set_bkops_enable(mmc);
985}
986#endif
987
988static int do_mmc_boot_wp(struct cmd_tbl *cmdtp, int flag,
989 int argc, char * const argv[])
990{
991 int err;
992 struct mmc *mmc;
993
994 mmc = init_mmc_device(curr_device, false);
995 if (!mmc)
996 return CMD_RET_FAILURE;
997 if (IS_SD(mmc)) {
998 printf("It is not an eMMC device\n");
999 return CMD_RET_FAILURE;
1000 }
1001 err = mmc_boot_wp(mmc);
1002 if (err)
1003 return CMD_RET_FAILURE;
1004 printf("boot areas protected\n");
1005 return CMD_RET_SUCCESS;
1006}
1007
1008static struct cmd_tbl cmd_mmc[] = {
1009 U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
1010 U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
1011 U_BOOT_CMD_MKENT(wp, 1, 0, do_mmc_boot_wp, "", ""),
1012#if CONFIG_IS_ENABLED(MMC_WRITE)
1013 U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""),
1014 U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""),
1015#endif
1016#if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
1017 U_BOOT_CMD_MKENT(swrite, 3, 0, do_mmc_sparse_write, "", ""),
1018#endif
1019 U_BOOT_CMD_MKENT(rescan, 2, 1, do_mmc_rescan, "", ""),
1020 U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""),
1021 U_BOOT_CMD_MKENT(dev, 4, 0, do_mmc_dev, "", ""),
1022 U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""),
1023#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
1024 U_BOOT_CMD_MKENT(hwpartition, 28, 0, do_mmc_hwpartition, "", ""),
1025#endif
1026#ifdef CONFIG_SUPPORT_EMMC_BOOT
1027 U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""),
1028 U_BOOT_CMD_MKENT(bootpart-resize, 4, 0, do_mmc_boot_resize, "", ""),
1029 U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""),
1030 U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""),
1031#endif
1032#if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
1033 U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""),
1034#endif
1035 U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""),
1036#ifdef CONFIG_CMD_BKOPS_ENABLE
1037 U_BOOT_CMD_MKENT(bkops-enable, 2, 0, do_mmc_bkops_enable, "", ""),
1038#endif
1039};
1040
1041static int do_mmcops(struct cmd_tbl *cmdtp, int flag, int argc,
1042 char *const argv[])
1043{
1044 struct cmd_tbl *cp;
1045
1046 cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
1047
1048
1049 argc--;
1050 argv++;
1051
1052 if (cp == NULL || argc > cp->maxargs)
1053 return CMD_RET_USAGE;
1054 if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
1055 return CMD_RET_SUCCESS;
1056
1057 if (curr_device < 0) {
1058 if (get_mmc_num() > 0) {
1059 curr_device = 0;
1060 } else {
1061 puts("No MMC device available\n");
1062 return CMD_RET_FAILURE;
1063 }
1064 }
1065 return cp->cmd(cmdtp, flag, argc, argv);
1066}
1067
1068U_BOOT_CMD(
1069 mmc, 29, 1, do_mmcops,
1070 "MMC sub system",
1071 "info - display info of the current MMC device\n"
1072 "mmc read addr blk# cnt\n"
1073 "mmc write addr blk# cnt\n"
1074#if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
1075 "mmc swrite addr blk#\n"
1076#endif
1077 "mmc erase blk# cnt\n"
1078 "mmc rescan [mode]\n"
1079 "mmc part - lists available partition on current mmc device\n"
1080 "mmc dev [dev] [part] [mode] - show or set current mmc device [partition] and set mode\n"
1081 " - the required speed mode is passed as the index from the following list\n"
1082 " [MMC_LEGACY, MMC_HS, SD_HS, MMC_HS_52, MMC_DDR_52, UHS_SDR12, UHS_SDR25,\n"
1083 " UHS_SDR50, UHS_DDR50, UHS_SDR104, MMC_HS_200, MMC_HS_400, MMC_HS_400_ES]\n"
1084 "mmc list - lists available devices\n"
1085 "mmc wp - power on write protect boot partitions\n"
1086#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
1087 "mmc hwpartition <USER> <GP> <MODE> - does hardware partitioning\n"
1088 " arguments (sizes in 512-byte blocks):\n"
1089 " USER - <user> <enh> <start> <cnt> <wrrel> <{on|off}>\n"
1090 " : sets user data area attributes\n"
1091 " GP - <{gp1|gp2|gp3|gp4}> <cnt> <enh> <wrrel> <{on|off}>\n"
1092 " : general purpose partition\n"
1093 " MODE - <{check|set|complete}>\n"
1094 " : mode, complete set partitioning completed\n"
1095 " WARNING: Partitioning is a write-once setting once it is set to complete.\n"
1096 " Power cycling is required to initialize partitions after set to complete.\n"
1097#endif
1098#ifdef CONFIG_SUPPORT_EMMC_BOOT
1099 "mmc bootbus <dev> <boot_bus_width> <reset_boot_bus_width> <boot_mode>\n"
1100 " - Set the BOOT_BUS_WIDTH field of the specified device\n"
1101 "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n"
1102 " - Change sizes of boot and RPMB partitions of specified device\n"
1103 "mmc partconf <dev> [[varname] | [<boot_ack> <boot_partition> <partition_access>]]\n"
1104 " - Show or change the bits of the PARTITION_CONFIG field of the specified device\n"
1105 " If showing the bits, optionally store the boot_partition field into varname\n"
1106 "mmc rst-function <dev> <value>\n"
1107 " - Change the RST_n_FUNCTION field of the specified device\n"
1108 " WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n"
1109#endif
1110#if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
1111 "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n"
1112 "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n"
1113 "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n"
1114 "mmc rpmb counter - read the value of the write counter\n"
1115#endif
1116 "mmc setdsr <value> - set DSR register value\n"
1117#ifdef CONFIG_CMD_BKOPS_ENABLE
1118 "mmc bkops-enable <dev> - enable background operations handshake on device\n"
1119 " WARNING: This is a write-once setting.\n"
1120#endif
1121 );
1122
1123
1124U_BOOT_CMD(
1125 mmcinfo, 1, 0, do_mmcinfo,
1126 "display MMC info",
1127 "- display info of the current MMC device"
1128);
1129