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}
123static struct mmc *init_mmc_device(int dev, bool force_init)
124{
125 struct mmc *mmc;
126 mmc = find_mmc_device(dev);
127 if (!mmc) {
128 printf("no mmc device at slot %x\n", dev);
129 return NULL;
130 }
131
132 if (!mmc_getcd(mmc))
133 force_init = true;
134
135 if (force_init)
136 mmc->has_init = 0;
137 if (mmc_init(mmc))
138 return NULL;
139
140#ifdef CONFIG_BLOCK_CACHE
141 struct blk_desc *bd = mmc_get_blk_desc(mmc);
142 blkcache_invalidate(bd->if_type, bd->devnum);
143#endif
144
145 return mmc;
146}
147
148static int do_mmcinfo(struct cmd_tbl *cmdtp, int flag, int argc,
149 char *const argv[])
150{
151 struct mmc *mmc;
152
153 if (curr_device < 0) {
154 if (get_mmc_num() > 0)
155 curr_device = 0;
156 else {
157 puts("No MMC device available\n");
158 return 1;
159 }
160 }
161
162 mmc = init_mmc_device(curr_device, false);
163 if (!mmc)
164 return CMD_RET_FAILURE;
165
166 print_mmcinfo(mmc);
167 return CMD_RET_SUCCESS;
168}
169
170#if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
171static int confirm_key_prog(void)
172{
173 puts("Warning: Programming authentication key can be done only once !\n"
174 " Use this command only if you are sure of what you are doing,\n"
175 "Really perform the key programming? <y/N> ");
176 if (confirm_yesno())
177 return 1;
178
179 puts("Authentication key programming aborted\n");
180 return 0;
181}
182
183static int do_mmcrpmb_key(struct cmd_tbl *cmdtp, int flag,
184 int argc, char *const argv[])
185{
186 void *key_addr;
187 struct mmc *mmc = find_mmc_device(curr_device);
188
189 if (argc != 2)
190 return CMD_RET_USAGE;
191
192 key_addr = (void *)simple_strtoul(argv[1], NULL, 16);
193 if (!confirm_key_prog())
194 return CMD_RET_FAILURE;
195 if (mmc_rpmb_set_key(mmc, key_addr)) {
196 printf("ERROR - Key already programmed ?\n");
197 return CMD_RET_FAILURE;
198 }
199 return CMD_RET_SUCCESS;
200}
201
202static int do_mmcrpmb_read(struct cmd_tbl *cmdtp, int flag,
203 int argc, char *const argv[])
204{
205 u16 blk, cnt;
206 void *addr;
207 int n;
208 void *key_addr = NULL;
209 struct mmc *mmc = find_mmc_device(curr_device);
210
211 if (argc < 4)
212 return CMD_RET_USAGE;
213
214 addr = (void *)simple_strtoul(argv[1], NULL, 16);
215 blk = simple_strtoul(argv[2], NULL, 16);
216 cnt = simple_strtoul(argv[3], NULL, 16);
217
218 if (argc == 5)
219 key_addr = (void *)simple_strtoul(argv[4], NULL, 16);
220
221 printf("\nMMC RPMB read: dev # %d, block # %d, count %d ... ",
222 curr_device, blk, cnt);
223 n = mmc_rpmb_read(mmc, addr, blk, cnt, key_addr);
224
225 printf("%d RPMB blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
226 if (n != cnt)
227 return CMD_RET_FAILURE;
228 return CMD_RET_SUCCESS;
229}
230
231static int do_mmcrpmb_write(struct cmd_tbl *cmdtp, int flag,
232 int argc, char *const argv[])
233{
234 u16 blk, cnt;
235 void *addr;
236 int n;
237 void *key_addr;
238 struct mmc *mmc = find_mmc_device(curr_device);
239
240 if (argc != 5)
241 return CMD_RET_USAGE;
242
243 addr = (void *)simple_strtoul(argv[1], NULL, 16);
244 blk = simple_strtoul(argv[2], NULL, 16);
245 cnt = simple_strtoul(argv[3], NULL, 16);
246 key_addr = (void *)simple_strtoul(argv[4], NULL, 16);
247
248 printf("\nMMC RPMB write: dev # %d, block # %d, count %d ... ",
249 curr_device, blk, cnt);
250 n = mmc_rpmb_write(mmc, addr, blk, cnt, key_addr);
251
252 printf("%d RPMB blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
253 if (n != cnt)
254 return CMD_RET_FAILURE;
255 return CMD_RET_SUCCESS;
256}
257
258static int do_mmcrpmb_counter(struct cmd_tbl *cmdtp, int flag,
259 int argc, char *const argv[])
260{
261 unsigned long counter;
262 struct mmc *mmc = find_mmc_device(curr_device);
263
264 if (mmc_rpmb_get_counter(mmc, &counter))
265 return CMD_RET_FAILURE;
266 printf("RPMB Write counter= %lx\n", counter);
267 return CMD_RET_SUCCESS;
268}
269
270static struct cmd_tbl cmd_rpmb[] = {
271 U_BOOT_CMD_MKENT(key, 2, 0, do_mmcrpmb_key, "", ""),
272 U_BOOT_CMD_MKENT(read, 5, 1, do_mmcrpmb_read, "", ""),
273 U_BOOT_CMD_MKENT(write, 5, 0, do_mmcrpmb_write, "", ""),
274 U_BOOT_CMD_MKENT(counter, 1, 1, do_mmcrpmb_counter, "", ""),
275};
276
277static int do_mmcrpmb(struct cmd_tbl *cmdtp, int flag,
278 int argc, char *const argv[])
279{
280 struct cmd_tbl *cp;
281 struct mmc *mmc;
282 char original_part;
283 int ret;
284
285 cp = find_cmd_tbl(argv[1], cmd_rpmb, ARRAY_SIZE(cmd_rpmb));
286
287
288 argc--;
289 argv++;
290
291 if (cp == NULL || argc > cp->maxargs)
292 return CMD_RET_USAGE;
293 if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
294 return CMD_RET_SUCCESS;
295
296 mmc = init_mmc_device(curr_device, false);
297 if (!mmc)
298 return CMD_RET_FAILURE;
299
300 if (!(mmc->version & MMC_VERSION_MMC)) {
301 printf("It is not an eMMC device\n");
302 return CMD_RET_FAILURE;
303 }
304 if (mmc->version < MMC_VERSION_4_41) {
305 printf("RPMB not supported before version 4.41\n");
306 return CMD_RET_FAILURE;
307 }
308
309#ifndef CONFIG_BLK
310 original_part = mmc->block_dev.hwpart;
311#else
312 original_part = mmc_get_blk_desc(mmc)->hwpart;
313#endif
314 if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, MMC_PART_RPMB) !=
315 0)
316 return CMD_RET_FAILURE;
317 ret = cp->cmd(cmdtp, flag, argc, argv);
318
319
320 if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, original_part) !=
321 0)
322 return CMD_RET_FAILURE;
323 return ret;
324}
325#endif
326
327static int do_mmc_read(struct cmd_tbl *cmdtp, int flag,
328 int argc, char *const argv[])
329{
330 struct mmc *mmc;
331 u32 blk, cnt, n;
332 void *addr;
333
334 if (argc != 4)
335 return CMD_RET_USAGE;
336
337 addr = (void *)simple_strtoul(argv[1], NULL, 16);
338 blk = simple_strtoul(argv[2], NULL, 16);
339 cnt = simple_strtoul(argv[3], NULL, 16);
340
341 mmc = init_mmc_device(curr_device, false);
342 if (!mmc)
343 return CMD_RET_FAILURE;
344
345 printf("\nMMC read: dev # %d, block # %d, count %d ... ",
346 curr_device, blk, cnt);
347
348 n = blk_dread(mmc_get_blk_desc(mmc), blk, cnt, addr);
349 printf("%d blocks read: %s\n", n, (n == cnt) ? "OK" : "ERROR");
350
351 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
352}
353
354#if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
355static lbaint_t mmc_sparse_write(struct sparse_storage *info, lbaint_t blk,
356 lbaint_t blkcnt, const void *buffer)
357{
358 struct blk_desc *dev_desc = info->priv;
359
360 return blk_dwrite(dev_desc, blk, blkcnt, buffer);
361}
362
363static lbaint_t mmc_sparse_reserve(struct sparse_storage *info,
364 lbaint_t blk, lbaint_t blkcnt)
365{
366 return blkcnt;
367}
368
369static int do_mmc_sparse_write(struct cmd_tbl *cmdtp, int flag,
370 int argc, char *const argv[])
371{
372 struct sparse_storage sparse;
373 struct blk_desc *dev_desc;
374 struct mmc *mmc;
375 char dest[11];
376 void *addr;
377 u32 blk;
378
379 if (argc != 3)
380 return CMD_RET_USAGE;
381
382 addr = (void *)simple_strtoul(argv[1], NULL, 16);
383 blk = simple_strtoul(argv[2], NULL, 16);
384
385 if (!is_sparse_image(addr)) {
386 printf("Not a sparse image\n");
387 return CMD_RET_FAILURE;
388 }
389
390 mmc = init_mmc_device(curr_device, false);
391 if (!mmc)
392 return CMD_RET_FAILURE;
393
394 printf("\nMMC Sparse write: dev # %d, block # %d ... ",
395 curr_device, blk);
396
397 if (mmc_getwp(mmc) == 1) {
398 printf("Error: card is write protected!\n");
399 return CMD_RET_FAILURE;
400 }
401
402 dev_desc = mmc_get_blk_desc(mmc);
403 sparse.priv = dev_desc;
404 sparse.blksz = 512;
405 sparse.start = blk;
406 sparse.size = dev_desc->lba - blk;
407 sparse.write = mmc_sparse_write;
408 sparse.reserve = mmc_sparse_reserve;
409 sparse.mssg = NULL;
410 sprintf(dest, "0x" LBAF, sparse.start * sparse.blksz);
411
412 if (write_sparse_image(&sparse, dest, addr, NULL))
413 return CMD_RET_FAILURE;
414 else
415 return CMD_RET_SUCCESS;
416}
417#endif
418
419#if CONFIG_IS_ENABLED(MMC_WRITE)
420static int do_mmc_write(struct cmd_tbl *cmdtp, int flag,
421 int argc, char *const argv[])
422{
423 struct mmc *mmc;
424 u32 blk, cnt, n;
425 void *addr;
426
427 if (argc != 4)
428 return CMD_RET_USAGE;
429
430 addr = (void *)simple_strtoul(argv[1], NULL, 16);
431 blk = simple_strtoul(argv[2], NULL, 16);
432 cnt = simple_strtoul(argv[3], NULL, 16);
433
434 mmc = init_mmc_device(curr_device, false);
435 if (!mmc)
436 return CMD_RET_FAILURE;
437
438 printf("\nMMC write: dev # %d, block # %d, count %d ... ",
439 curr_device, blk, cnt);
440
441 if (mmc_getwp(mmc) == 1) {
442 printf("Error: card is write protected!\n");
443 return CMD_RET_FAILURE;
444 }
445 n = blk_dwrite(mmc_get_blk_desc(mmc), blk, cnt, addr);
446 printf("%d blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR");
447
448 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
449}
450
451static int do_mmc_erase(struct cmd_tbl *cmdtp, int flag,
452 int argc, char *const argv[])
453{
454 struct mmc *mmc;
455 u32 blk, cnt, n;
456
457 if (argc != 3)
458 return CMD_RET_USAGE;
459
460 blk = simple_strtoul(argv[1], NULL, 16);
461 cnt = simple_strtoul(argv[2], NULL, 16);
462
463 mmc = init_mmc_device(curr_device, false);
464 if (!mmc)
465 return CMD_RET_FAILURE;
466
467 printf("\nMMC erase: dev # %d, block # %d, count %d ... ",
468 curr_device, blk, cnt);
469
470 if (mmc_getwp(mmc) == 1) {
471 printf("Error: card is write protected!\n");
472 return CMD_RET_FAILURE;
473 }
474 n = blk_derase(mmc_get_blk_desc(mmc), blk, cnt);
475 printf("%d blocks erased: %s\n", n, (n == cnt) ? "OK" : "ERROR");
476
477 return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
478}
479#endif
480
481static int do_mmc_rescan(struct cmd_tbl *cmdtp, int flag,
482 int argc, char *const argv[])
483{
484 struct mmc *mmc;
485
486 mmc = init_mmc_device(curr_device, true);
487 if (!mmc)
488 return CMD_RET_FAILURE;
489
490 return CMD_RET_SUCCESS;
491}
492
493static int do_mmc_part(struct cmd_tbl *cmdtp, int flag,
494 int argc, char *const argv[])
495{
496 struct blk_desc *mmc_dev;
497 struct mmc *mmc;
498
499 mmc = init_mmc_device(curr_device, false);
500 if (!mmc)
501 return CMD_RET_FAILURE;
502
503 mmc_dev = blk_get_devnum_by_type(IF_TYPE_MMC, curr_device);
504 if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
505 part_print(mmc_dev);
506 return CMD_RET_SUCCESS;
507 }
508
509 puts("get mmc type error!\n");
510 return CMD_RET_FAILURE;
511}
512
513static int do_mmc_dev(struct cmd_tbl *cmdtp, int flag,
514 int argc, char *const argv[])
515{
516 int dev, part = 0, ret;
517 struct mmc *mmc;
518
519 if (argc == 1) {
520 dev = curr_device;
521 } else if (argc == 2) {
522 dev = simple_strtoul(argv[1], NULL, 10);
523 } else if (argc == 3) {
524 dev = (int)simple_strtoul(argv[1], NULL, 10);
525 part = (int)simple_strtoul(argv[2], NULL, 10);
526 if (part > PART_ACCESS_MASK) {
527 printf("#part_num shouldn't be larger than %d\n",
528 PART_ACCESS_MASK);
529 return CMD_RET_FAILURE;
530 }
531 } else {
532 return CMD_RET_USAGE;
533 }
534
535 mmc = init_mmc_device(dev, true);
536 if (!mmc)
537 return CMD_RET_FAILURE;
538
539 ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
540 printf("switch to partitions #%d, %s\n",
541 part, (!ret) ? "OK" : "ERROR");
542 if (ret)
543 return 1;
544
545 curr_device = dev;
546 if (mmc->part_config == MMCPART_NOAVAILABLE)
547 printf("mmc%d is current device\n", curr_device);
548 else
549 printf("mmc%d(part %d) is current device\n",
550 curr_device, mmc_get_blk_desc(mmc)->hwpart);
551
552 return CMD_RET_SUCCESS;
553}
554
555static int do_mmc_list(struct cmd_tbl *cmdtp, int flag,
556 int argc, char *const argv[])
557{
558 print_mmc_devices('\n');
559 return CMD_RET_SUCCESS;
560}
561
562#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
563static int parse_hwpart_user(struct mmc_hwpart_conf *pconf,
564 int argc, char *const argv[])
565{
566 int i = 0;
567
568 memset(&pconf->user, 0, sizeof(pconf->user));
569
570 while (i < argc) {
571 if (!strcmp(argv[i], "enh")) {
572 if (i + 2 >= argc)
573 return -1;
574 pconf->user.enh_start =
575 simple_strtoul(argv[i+1], NULL, 10);
576 pconf->user.enh_size =
577 simple_strtoul(argv[i+2], NULL, 10);
578 i += 3;
579 } else if (!strcmp(argv[i], "wrrel")) {
580 if (i + 1 >= argc)
581 return -1;
582 pconf->user.wr_rel_change = 1;
583 if (!strcmp(argv[i+1], "on"))
584 pconf->user.wr_rel_set = 1;
585 else if (!strcmp(argv[i+1], "off"))
586 pconf->user.wr_rel_set = 0;
587 else
588 return -1;
589 i += 2;
590 } else {
591 break;
592 }
593 }
594 return i;
595}
596
597static int parse_hwpart_gp(struct mmc_hwpart_conf *pconf, int pidx,
598 int argc, char *const argv[])
599{
600 int i;
601
602 memset(&pconf->gp_part[pidx], 0, sizeof(pconf->gp_part[pidx]));
603
604 if (1 >= argc)
605 return -1;
606 pconf->gp_part[pidx].size = simple_strtoul(argv[0], NULL, 10);
607
608 i = 1;
609 while (i < argc) {
610 if (!strcmp(argv[i], "enh")) {
611 pconf->gp_part[pidx].enhanced = 1;
612 i += 1;
613 } else if (!strcmp(argv[i], "wrrel")) {
614 if (i + 1 >= argc)
615 return -1;
616 pconf->gp_part[pidx].wr_rel_change = 1;
617 if (!strcmp(argv[i+1], "on"))
618 pconf->gp_part[pidx].wr_rel_set = 1;
619 else if (!strcmp(argv[i+1], "off"))
620 pconf->gp_part[pidx].wr_rel_set = 0;
621 else
622 return -1;
623 i += 2;
624 } else {
625 break;
626 }
627 }
628 return i;
629}
630
631static int do_mmc_hwpartition(struct cmd_tbl *cmdtp, int flag,
632 int argc, char *const argv[])
633{
634 struct mmc *mmc;
635 struct mmc_hwpart_conf pconf = { };
636 enum mmc_hwpart_conf_mode mode = MMC_HWPART_CONF_CHECK;
637 int i, r, pidx;
638
639 mmc = init_mmc_device(curr_device, false);
640 if (!mmc)
641 return CMD_RET_FAILURE;
642
643 if (argc < 1)
644 return CMD_RET_USAGE;
645 i = 1;
646 while (i < argc) {
647 if (!strcmp(argv[i], "user")) {
648 i++;
649 r = parse_hwpart_user(&pconf, argc-i, &argv[i]);
650 if (r < 0)
651 return CMD_RET_USAGE;
652 i += r;
653 } else if (!strncmp(argv[i], "gp", 2) &&
654 strlen(argv[i]) == 3 &&
655 argv[i][2] >= '1' && argv[i][2] <= '4') {
656 pidx = argv[i][2] - '1';
657 i++;
658 r = parse_hwpart_gp(&pconf, pidx, argc-i, &argv[i]);
659 if (r < 0)
660 return CMD_RET_USAGE;
661 i += r;
662 } else if (!strcmp(argv[i], "check")) {
663 mode = MMC_HWPART_CONF_CHECK;
664 i++;
665 } else if (!strcmp(argv[i], "set")) {
666 mode = MMC_HWPART_CONF_SET;
667 i++;
668 } else if (!strcmp(argv[i], "complete")) {
669 mode = MMC_HWPART_CONF_COMPLETE;
670 i++;
671 } else {
672 return CMD_RET_USAGE;
673 }
674 }
675
676 puts("Partition configuration:\n");
677 if (pconf.user.enh_size) {
678 puts("\tUser Enhanced Start: ");
679 print_size(((u64)pconf.user.enh_start) << 9, "\n");
680 puts("\tUser Enhanced Size: ");
681 print_size(((u64)pconf.user.enh_size) << 9, "\n");
682 } else {
683 puts("\tNo enhanced user data area\n");
684 }
685 if (pconf.user.wr_rel_change)
686 printf("\tUser partition write reliability: %s\n",
687 pconf.user.wr_rel_set ? "on" : "off");
688 for (pidx = 0; pidx < 4; pidx++) {
689 if (pconf.gp_part[pidx].size) {
690 printf("\tGP%i Capacity: ", pidx+1);
691 print_size(((u64)pconf.gp_part[pidx].size) << 9,
692 pconf.gp_part[pidx].enhanced ?
693 " ENH\n" : "\n");
694 } else {
695 printf("\tNo GP%i partition\n", pidx+1);
696 }
697 if (pconf.gp_part[pidx].wr_rel_change)
698 printf("\tGP%i write reliability: %s\n", pidx+1,
699 pconf.gp_part[pidx].wr_rel_set ? "on" : "off");
700 }
701
702 if (!mmc_hwpart_config(mmc, &pconf, mode)) {
703 if (mode == MMC_HWPART_CONF_COMPLETE)
704 puts("Partitioning successful, "
705 "power-cycle to make effective\n");
706 return CMD_RET_SUCCESS;
707 } else {
708 puts("Failed!\n");
709 return CMD_RET_FAILURE;
710 }
711}
712#endif
713
714#ifdef CONFIG_SUPPORT_EMMC_BOOT
715static int do_mmc_bootbus(struct cmd_tbl *cmdtp, int flag,
716 int argc, char *const argv[])
717{
718 int dev;
719 struct mmc *mmc;
720 u8 width, reset, mode;
721
722 if (argc != 5)
723 return CMD_RET_USAGE;
724 dev = simple_strtoul(argv[1], NULL, 10);
725 width = simple_strtoul(argv[2], NULL, 10);
726 reset = simple_strtoul(argv[3], NULL, 10);
727 mode = simple_strtoul(argv[4], NULL, 10);
728
729 mmc = init_mmc_device(dev, false);
730 if (!mmc)
731 return CMD_RET_FAILURE;
732
733 if (IS_SD(mmc)) {
734 puts("BOOT_BUS_WIDTH only exists on eMMC\n");
735 return CMD_RET_FAILURE;
736 }
737
738
739 return mmc_set_boot_bus_width(mmc, width, reset, mode);
740}
741
742static int do_mmc_boot_resize(struct cmd_tbl *cmdtp, int flag,
743 int argc, char *const argv[])
744{
745 int dev;
746 struct mmc *mmc;
747 u32 bootsize, rpmbsize;
748
749 if (argc != 4)
750 return CMD_RET_USAGE;
751 dev = simple_strtoul(argv[1], NULL, 10);
752 bootsize = simple_strtoul(argv[2], NULL, 10);
753 rpmbsize = simple_strtoul(argv[3], NULL, 10);
754
755 mmc = init_mmc_device(dev, false);
756 if (!mmc)
757 return CMD_RET_FAILURE;
758
759 if (IS_SD(mmc)) {
760 printf("It is not an eMMC device\n");
761 return CMD_RET_FAILURE;
762 }
763
764 if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) {
765 printf("EMMC boot partition Size change Failed.\n");
766 return CMD_RET_FAILURE;
767 }
768
769 printf("EMMC boot partition Size %d MB\n", bootsize);
770 printf("EMMC RPMB partition Size %d MB\n", rpmbsize);
771 return CMD_RET_SUCCESS;
772}
773
774static int mmc_partconf_print(struct mmc *mmc)
775{
776 u8 ack, access, part;
777
778 if (mmc->part_config == MMCPART_NOAVAILABLE) {
779 printf("No part_config info for ver. 0x%x\n", mmc->version);
780 return CMD_RET_FAILURE;
781 }
782
783 access = EXT_CSD_EXTRACT_PARTITION_ACCESS(mmc->part_config);
784 ack = EXT_CSD_EXTRACT_BOOT_ACK(mmc->part_config);
785 part = EXT_CSD_EXTRACT_BOOT_PART(mmc->part_config);
786
787 printf("EXT_CSD[179], PARTITION_CONFIG:\n"
788 "BOOT_ACK: 0x%x\n"
789 "BOOT_PARTITION_ENABLE: 0x%x\n"
790 "PARTITION_ACCESS: 0x%x\n", ack, part, access);
791
792 return CMD_RET_SUCCESS;
793}
794
795static int do_mmc_partconf(struct cmd_tbl *cmdtp, int flag,
796 int argc, char *const argv[])
797{
798 int dev;
799 struct mmc *mmc;
800 u8 ack, part_num, access;
801
802 if (argc != 2 && argc != 5)
803 return CMD_RET_USAGE;
804
805 dev = simple_strtoul(argv[1], NULL, 10);
806
807 mmc = init_mmc_device(dev, false);
808 if (!mmc)
809 return CMD_RET_FAILURE;
810
811 if (IS_SD(mmc)) {
812 puts("PARTITION_CONFIG only exists on eMMC\n");
813 return CMD_RET_FAILURE;
814 }
815
816 if (argc == 2)
817 return mmc_partconf_print(mmc);
818
819 ack = simple_strtoul(argv[2], NULL, 10);
820 part_num = simple_strtoul(argv[3], NULL, 10);
821 access = simple_strtoul(argv[4], NULL, 10);
822
823
824 return mmc_set_part_conf(mmc, ack, part_num, access);
825}
826
827static int do_mmc_rst_func(struct cmd_tbl *cmdtp, int flag,
828 int argc, char *const argv[])
829{
830 int dev;
831 struct mmc *mmc;
832 u8 enable;
833
834
835
836
837
838
839 if (argc != 3)
840 return CMD_RET_USAGE;
841
842 dev = simple_strtoul(argv[1], NULL, 10);
843 enable = simple_strtoul(argv[2], NULL, 10);
844
845 if (enable > 2) {
846 puts("Invalid RST_n_ENABLE value\n");
847 return CMD_RET_USAGE;
848 }
849
850 mmc = init_mmc_device(dev, false);
851 if (!mmc)
852 return CMD_RET_FAILURE;
853
854 if (IS_SD(mmc)) {
855 puts("RST_n_FUNCTION only exists on eMMC\n");
856 return CMD_RET_FAILURE;
857 }
858
859 return mmc_set_rst_n_function(mmc, enable);
860}
861#endif
862static int do_mmc_setdsr(struct cmd_tbl *cmdtp, int flag,
863 int argc, char *const argv[])
864{
865 struct mmc *mmc;
866 u32 val;
867 int ret;
868
869 if (argc != 2)
870 return CMD_RET_USAGE;
871 val = simple_strtoul(argv[1], NULL, 16);
872
873 mmc = find_mmc_device(curr_device);
874 if (!mmc) {
875 printf("no mmc device at slot %x\n", curr_device);
876 return CMD_RET_FAILURE;
877 }
878 ret = mmc_set_dsr(mmc, val);
879 printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR");
880 if (!ret) {
881 mmc->has_init = 0;
882 if (mmc_init(mmc))
883 return CMD_RET_FAILURE;
884 else
885 return CMD_RET_SUCCESS;
886 }
887 return ret;
888}
889
890#ifdef CONFIG_CMD_BKOPS_ENABLE
891static int do_mmc_bkops_enable(struct cmd_tbl *cmdtp, int flag,
892 int argc, char *const argv[])
893{
894 int dev;
895 struct mmc *mmc;
896
897 if (argc != 2)
898 return CMD_RET_USAGE;
899
900 dev = simple_strtoul(argv[1], NULL, 10);
901
902 mmc = init_mmc_device(dev, false);
903 if (!mmc)
904 return CMD_RET_FAILURE;
905
906 if (IS_SD(mmc)) {
907 puts("BKOPS_EN only exists on eMMC\n");
908 return CMD_RET_FAILURE;
909 }
910
911 return mmc_set_bkops_enable(mmc);
912}
913#endif
914
915static int do_mmc_boot_wp(struct cmd_tbl *cmdtp, int flag,
916 int argc, char * const argv[])
917{
918 int err;
919 struct mmc *mmc;
920
921 mmc = init_mmc_device(curr_device, false);
922 if (!mmc)
923 return CMD_RET_FAILURE;
924 if (IS_SD(mmc)) {
925 printf("It is not an eMMC device\n");
926 return CMD_RET_FAILURE;
927 }
928 err = mmc_boot_wp(mmc);
929 if (err)
930 return CMD_RET_FAILURE;
931 printf("boot areas protected\n");
932 return CMD_RET_SUCCESS;
933}
934
935static struct cmd_tbl cmd_mmc[] = {
936 U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
937 U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
938 U_BOOT_CMD_MKENT(wp, 1, 0, do_mmc_boot_wp, "", ""),
939#if CONFIG_IS_ENABLED(MMC_WRITE)
940 U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""),
941 U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""),
942#endif
943#if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
944 U_BOOT_CMD_MKENT(swrite, 3, 0, do_mmc_sparse_write, "", ""),
945#endif
946 U_BOOT_CMD_MKENT(rescan, 1, 1, do_mmc_rescan, "", ""),
947 U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""),
948 U_BOOT_CMD_MKENT(dev, 3, 0, do_mmc_dev, "", ""),
949 U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""),
950#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
951 U_BOOT_CMD_MKENT(hwpartition, 28, 0, do_mmc_hwpartition, "", ""),
952#endif
953#ifdef CONFIG_SUPPORT_EMMC_BOOT
954 U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""),
955 U_BOOT_CMD_MKENT(bootpart-resize, 4, 0, do_mmc_boot_resize, "", ""),
956 U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""),
957 U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""),
958#endif
959#if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
960 U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""),
961#endif
962 U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""),
963#ifdef CONFIG_CMD_BKOPS_ENABLE
964 U_BOOT_CMD_MKENT(bkops-enable, 2, 0, do_mmc_bkops_enable, "", ""),
965#endif
966};
967
968static int do_mmcops(struct cmd_tbl *cmdtp, int flag, int argc,
969 char *const argv[])
970{
971 struct cmd_tbl *cp;
972
973 cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
974
975
976 argc--;
977 argv++;
978
979 if (cp == NULL || argc > cp->maxargs)
980 return CMD_RET_USAGE;
981 if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
982 return CMD_RET_SUCCESS;
983
984 if (curr_device < 0) {
985 if (get_mmc_num() > 0) {
986 curr_device = 0;
987 } else {
988 puts("No MMC device available\n");
989 return CMD_RET_FAILURE;
990 }
991 }
992 return cp->cmd(cmdtp, flag, argc, argv);
993}
994
995U_BOOT_CMD(
996 mmc, 29, 1, do_mmcops,
997 "MMC sub system",
998 "info - display info of the current MMC device\n"
999 "mmc read addr blk# cnt\n"
1000 "mmc write addr blk# cnt\n"
1001#if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
1002 "mmc swrite addr blk#\n"
1003#endif
1004 "mmc erase blk# cnt\n"
1005 "mmc rescan\n"
1006 "mmc part - lists available partition on current mmc device\n"
1007 "mmc dev [dev] [part] - show or set current mmc device [partition]\n"
1008 "mmc list - lists available devices\n"
1009 "mmc wp - power on write protect boot partitions\n"
1010#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
1011 "mmc hwpartition [args...] - does hardware partitioning\n"
1012 " arguments (sizes in 512-byte blocks):\n"
1013 " [user [enh start cnt] [wrrel {on|off}]] - sets user data area attributes\n"
1014 " [gp1|gp2|gp3|gp4 cnt [enh] [wrrel {on|off}]] - general purpose partition\n"
1015 " [check|set|complete] - mode, complete set partitioning completed\n"
1016 " WARNING: Partitioning is a write-once setting once it is set to complete.\n"
1017 " Power cycling is required to initialize partitions after set to complete.\n"
1018#endif
1019#ifdef CONFIG_SUPPORT_EMMC_BOOT
1020 "mmc bootbus dev boot_bus_width reset_boot_bus_width boot_mode\n"
1021 " - Set the BOOT_BUS_WIDTH field of the specified device\n"
1022 "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n"
1023 " - Change sizes of boot and RPMB partitions of specified device\n"
1024 "mmc partconf dev [boot_ack boot_partition partition_access]\n"
1025 " - Show or change the bits of the PARTITION_CONFIG field of the specified device\n"
1026 "mmc rst-function dev value\n"
1027 " - Change the RST_n_FUNCTION field of the specified device\n"
1028 " WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n"
1029#endif
1030#if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
1031 "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n"
1032 "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n"
1033 "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n"
1034 "mmc rpmb counter - read the value of the write counter\n"
1035#endif
1036 "mmc setdsr <value> - set DSR register value\n"
1037#ifdef CONFIG_CMD_BKOPS_ENABLE
1038 "mmc bkops-enable <dev> - enable background operations handshake on device\n"
1039 " WARNING: This is a write-once setting.\n"
1040#endif
1041 );
1042
1043
1044U_BOOT_CMD(
1045 mmcinfo, 1, 0, do_mmcinfo,
1046 "display MMC info",
1047 "- display info of the current MMC device"
1048);
1049
