1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2003
4 * Kyle Harris, kharris@nexus-tech.net
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
17 static int curr_device = -1;
18
print_mmcinfo(struct mmc * mmc)19 static 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 }
init_mmc_device(int dev,bool force_init)123 static 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
do_mmcinfo(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])148 static 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)
confirm_key_prog(void)171 static 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
do_mmcrpmb_key(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])183 static 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
do_mmcrpmb_read(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])202 static 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
do_mmcrpmb_write(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])231 static 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
do_mmcrpmb_counter(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])258 static 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
270 static 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
do_mmcrpmb(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])277 static 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 /* Drop the rpmb subcommand */
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 /* Switch to the RPMB partition */
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 /* Return to original partition */
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
do_mmc_read(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])327 static 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)
mmc_sparse_write(struct sparse_storage * info,lbaint_t blk,lbaint_t blkcnt,const void * buffer)355 static 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
mmc_sparse_reserve(struct sparse_storage * info,lbaint_t blk,lbaint_t blkcnt)363 static lbaint_t mmc_sparse_reserve(struct sparse_storage *info,
364 lbaint_t blk, lbaint_t blkcnt)
365 {
366 return blkcnt;
367 }
368
do_mmc_sparse_write(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])369 static 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)
do_mmc_write(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])420 static 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
do_mmc_erase(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])451 static 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
do_mmc_rescan(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])481 static 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
do_mmc_part(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])493 static 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
do_mmc_dev(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])513 static 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
do_mmc_list(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])555 static 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)
parse_hwpart_user(struct mmc_hwpart_conf * pconf,int argc,char * const argv[])563 static 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
parse_hwpart_gp(struct mmc_hwpart_conf * pconf,int pidx,int argc,char * const argv[])597 static 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
do_mmc_hwpartition(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])631 static 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
do_mmc_bootbus(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])715 static 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 * BOOT_BUS_CONDITIONS[177]
740 * BOOT_MODE[4:3]
741 * 0x0 : Use SDR + Backward compatible timing in boot operation
742 * 0x1 : Use SDR + High Speed Timing in boot operation mode
743 * 0x2 : Use DDR in boot operation
744 * RESET_BOOT_BUS_CONDITIONS
745 * 0x0 : Reset bus width to x1, SDR, Backward compatible
746 * 0x1 : Retain BOOT_BUS_WIDTH and BOOT_MODE
747 * BOOT_BUS_WIDTH
748 * 0x0 : x1(sdr) or x4 (ddr) buswidth
749 * 0x1 : x4(sdr/ddr) buswith
750 * 0x2 : x8(sdr/ddr) buswith
751 *
752 */
753 if (width >= 0x3) {
754 printf("boot_bus_width %d is invalid\n", width);
755 return CMD_RET_FAILURE;
756 }
757
758 if (reset >= 0x2) {
759 printf("reset_boot_bus_width %d is invalid\n", reset);
760 return CMD_RET_FAILURE;
761 }
762
763 if (mode >= 0x3) {
764 printf("reset_boot_bus_width %d is invalid\n", mode);
765 return CMD_RET_FAILURE;
766 }
767
768 /* acknowledge to be sent during boot operation */
769 if (mmc_set_boot_bus_width(mmc, width, reset, mode)) {
770 puts("BOOT_BUS_WIDTH is failed to change.\n");
771 return CMD_RET_FAILURE;
772 }
773
774 printf("Set to BOOT_BUS_WIDTH = 0x%x, RESET = 0x%x, BOOT_MODE = 0x%x\n",
775 width, reset, mode);
776 return CMD_RET_SUCCESS;
777 }
778
do_mmc_boot_resize(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])779 static int do_mmc_boot_resize(struct cmd_tbl *cmdtp, int flag,
780 int argc, char *const argv[])
781 {
782 int dev;
783 struct mmc *mmc;
784 u32 bootsize, rpmbsize;
785
786 if (argc != 4)
787 return CMD_RET_USAGE;
788 dev = simple_strtoul(argv[1], NULL, 10);
789 bootsize = simple_strtoul(argv[2], NULL, 10);
790 rpmbsize = simple_strtoul(argv[3], NULL, 10);
791
792 mmc = init_mmc_device(dev, false);
793 if (!mmc)
794 return CMD_RET_FAILURE;
795
796 if (IS_SD(mmc)) {
797 printf("It is not an eMMC device\n");
798 return CMD_RET_FAILURE;
799 }
800
801 if (mmc_boot_partition_size_change(mmc, bootsize, rpmbsize)) {
802 printf("EMMC boot partition Size change Failed.\n");
803 return CMD_RET_FAILURE;
804 }
805
806 printf("EMMC boot partition Size %d MB\n", bootsize);
807 printf("EMMC RPMB partition Size %d MB\n", rpmbsize);
808 return CMD_RET_SUCCESS;
809 }
810
mmc_partconf_print(struct mmc * mmc,const char * varname)811 static int mmc_partconf_print(struct mmc *mmc, const char *varname)
812 {
813 u8 ack, access, part;
814
815 if (mmc->part_config == MMCPART_NOAVAILABLE) {
816 printf("No part_config info for ver. 0x%x\n", mmc->version);
817 return CMD_RET_FAILURE;
818 }
819
820 access = EXT_CSD_EXTRACT_PARTITION_ACCESS(mmc->part_config);
821 ack = EXT_CSD_EXTRACT_BOOT_ACK(mmc->part_config);
822 part = EXT_CSD_EXTRACT_BOOT_PART(mmc->part_config);
823
824 if(varname)
825 env_set_hex(varname, part);
826
827 printf("EXT_CSD[179], PARTITION_CONFIG:\n"
828 "BOOT_ACK: 0x%x\n"
829 "BOOT_PARTITION_ENABLE: 0x%x\n"
830 "PARTITION_ACCESS: 0x%x\n", ack, part, access);
831
832 return CMD_RET_SUCCESS;
833 }
834
do_mmc_partconf(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])835 static int do_mmc_partconf(struct cmd_tbl *cmdtp, int flag,
836 int argc, char *const argv[])
837 {
838 int dev;
839 struct mmc *mmc;
840 u8 ack, part_num, access;
841
842 if (argc != 2 && argc != 3 && argc != 5)
843 return CMD_RET_USAGE;
844
845 dev = simple_strtoul(argv[1], NULL, 10);
846
847 mmc = init_mmc_device(dev, false);
848 if (!mmc)
849 return CMD_RET_FAILURE;
850
851 if (IS_SD(mmc)) {
852 puts("PARTITION_CONFIG only exists on eMMC\n");
853 return CMD_RET_FAILURE;
854 }
855
856 if (argc == 2 || argc == 3)
857 return mmc_partconf_print(mmc, argc == 3 ? argv[2] : NULL);
858
859 ack = simple_strtoul(argv[2], NULL, 10);
860 part_num = simple_strtoul(argv[3], NULL, 10);
861 access = simple_strtoul(argv[4], NULL, 10);
862
863 /* acknowledge to be sent during boot operation */
864 return mmc_set_part_conf(mmc, ack, part_num, access);
865 }
866
do_mmc_rst_func(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])867 static int do_mmc_rst_func(struct cmd_tbl *cmdtp, int flag,
868 int argc, char *const argv[])
869 {
870 int dev;
871 struct mmc *mmc;
872 u8 enable;
873
874 /*
875 * Set the RST_n_ENABLE bit of RST_n_FUNCTION
876 * The only valid values are 0x0, 0x1 and 0x2 and writing
877 * a value of 0x1 or 0x2 sets the value permanently.
878 */
879 if (argc != 3)
880 return CMD_RET_USAGE;
881
882 dev = simple_strtoul(argv[1], NULL, 10);
883 enable = simple_strtoul(argv[2], NULL, 10);
884
885 if (enable > 2) {
886 puts("Invalid RST_n_ENABLE value\n");
887 return CMD_RET_USAGE;
888 }
889
890 mmc = init_mmc_device(dev, false);
891 if (!mmc)
892 return CMD_RET_FAILURE;
893
894 if (IS_SD(mmc)) {
895 puts("RST_n_FUNCTION only exists on eMMC\n");
896 return CMD_RET_FAILURE;
897 }
898
899 return mmc_set_rst_n_function(mmc, enable);
900 }
901 #endif
do_mmc_setdsr(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])902 static int do_mmc_setdsr(struct cmd_tbl *cmdtp, int flag,
903 int argc, char *const argv[])
904 {
905 struct mmc *mmc;
906 u32 val;
907 int ret;
908
909 if (argc != 2)
910 return CMD_RET_USAGE;
911 val = simple_strtoul(argv[1], NULL, 16);
912
913 mmc = find_mmc_device(curr_device);
914 if (!mmc) {
915 printf("no mmc device at slot %x\n", curr_device);
916 return CMD_RET_FAILURE;
917 }
918 ret = mmc_set_dsr(mmc, val);
919 printf("set dsr %s\n", (!ret) ? "OK, force rescan" : "ERROR");
920 if (!ret) {
921 mmc->has_init = 0;
922 if (mmc_init(mmc))
923 return CMD_RET_FAILURE;
924 else
925 return CMD_RET_SUCCESS;
926 }
927 return ret;
928 }
929
930 #ifdef CONFIG_CMD_BKOPS_ENABLE
do_mmc_bkops_enable(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])931 static int do_mmc_bkops_enable(struct cmd_tbl *cmdtp, int flag,
932 int argc, char *const argv[])
933 {
934 int dev;
935 struct mmc *mmc;
936
937 if (argc != 2)
938 return CMD_RET_USAGE;
939
940 dev = simple_strtoul(argv[1], NULL, 10);
941
942 mmc = init_mmc_device(dev, false);
943 if (!mmc)
944 return CMD_RET_FAILURE;
945
946 if (IS_SD(mmc)) {
947 puts("BKOPS_EN only exists on eMMC\n");
948 return CMD_RET_FAILURE;
949 }
950
951 return mmc_set_bkops_enable(mmc);
952 }
953 #endif
954
do_mmc_boot_wp(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])955 static int do_mmc_boot_wp(struct cmd_tbl *cmdtp, int flag,
956 int argc, char * const argv[])
957 {
958 int err;
959 struct mmc *mmc;
960
961 mmc = init_mmc_device(curr_device, false);
962 if (!mmc)
963 return CMD_RET_FAILURE;
964 if (IS_SD(mmc)) {
965 printf("It is not an eMMC device\n");
966 return CMD_RET_FAILURE;
967 }
968 err = mmc_boot_wp(mmc);
969 if (err)
970 return CMD_RET_FAILURE;
971 printf("boot areas protected\n");
972 return CMD_RET_SUCCESS;
973 }
974
975 static struct cmd_tbl cmd_mmc[] = {
976 U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
977 U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
978 U_BOOT_CMD_MKENT(wp, 1, 0, do_mmc_boot_wp, "", ""),
979 #if CONFIG_IS_ENABLED(MMC_WRITE)
980 U_BOOT_CMD_MKENT(write, 4, 0, do_mmc_write, "", ""),
981 U_BOOT_CMD_MKENT(erase, 3, 0, do_mmc_erase, "", ""),
982 #endif
983 #if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
984 U_BOOT_CMD_MKENT(swrite, 3, 0, do_mmc_sparse_write, "", ""),
985 #endif
986 U_BOOT_CMD_MKENT(rescan, 1, 1, do_mmc_rescan, "", ""),
987 U_BOOT_CMD_MKENT(part, 1, 1, do_mmc_part, "", ""),
988 U_BOOT_CMD_MKENT(dev, 3, 0, do_mmc_dev, "", ""),
989 U_BOOT_CMD_MKENT(list, 1, 1, do_mmc_list, "", ""),
990 #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
991 U_BOOT_CMD_MKENT(hwpartition, 28, 0, do_mmc_hwpartition, "", ""),
992 #endif
993 #ifdef CONFIG_SUPPORT_EMMC_BOOT
994 U_BOOT_CMD_MKENT(bootbus, 5, 0, do_mmc_bootbus, "", ""),
995 U_BOOT_CMD_MKENT(bootpart-resize, 4, 0, do_mmc_boot_resize, "", ""),
996 U_BOOT_CMD_MKENT(partconf, 5, 0, do_mmc_partconf, "", ""),
997 U_BOOT_CMD_MKENT(rst-function, 3, 0, do_mmc_rst_func, "", ""),
998 #endif
999 #if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
1000 U_BOOT_CMD_MKENT(rpmb, CONFIG_SYS_MAXARGS, 1, do_mmcrpmb, "", ""),
1001 #endif
1002 U_BOOT_CMD_MKENT(setdsr, 2, 0, do_mmc_setdsr, "", ""),
1003 #ifdef CONFIG_CMD_BKOPS_ENABLE
1004 U_BOOT_CMD_MKENT(bkops-enable, 2, 0, do_mmc_bkops_enable, "", ""),
1005 #endif
1006 };
1007
do_mmcops(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])1008 static int do_mmcops(struct cmd_tbl *cmdtp, int flag, int argc,
1009 char *const argv[])
1010 {
1011 struct cmd_tbl *cp;
1012
1013 cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
1014
1015 /* Drop the mmc command */
1016 argc--;
1017 argv++;
1018
1019 if (cp == NULL || argc > cp->maxargs)
1020 return CMD_RET_USAGE;
1021 if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
1022 return CMD_RET_SUCCESS;
1023
1024 if (curr_device < 0) {
1025 if (get_mmc_num() > 0) {
1026 curr_device = 0;
1027 } else {
1028 puts("No MMC device available\n");
1029 return CMD_RET_FAILURE;
1030 }
1031 }
1032 return cp->cmd(cmdtp, flag, argc, argv);
1033 }
1034
1035 U_BOOT_CMD(
1036 mmc, 29, 1, do_mmcops,
1037 "MMC sub system",
1038 "info - display info of the current MMC device\n"
1039 "mmc read addr blk# cnt\n"
1040 "mmc write addr blk# cnt\n"
1041 #if CONFIG_IS_ENABLED(CMD_MMC_SWRITE)
1042 "mmc swrite addr blk#\n"
1043 #endif
1044 "mmc erase blk# cnt\n"
1045 "mmc rescan\n"
1046 "mmc part - lists available partition on current mmc device\n"
1047 "mmc dev [dev] [part] - show or set current mmc device [partition]\n"
1048 "mmc list - lists available devices\n"
1049 "mmc wp - power on write protect boot partitions\n"
1050 #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
1051 "mmc hwpartition <USER> <GP> <MODE> - does hardware partitioning\n"
1052 " arguments (sizes in 512-byte blocks):\n"
1053 " USER - <user> <enh> <start> <cnt> <wrrel> <{on|off}>\n"
1054 " : sets user data area attributes\n"
1055 " GP - <{gp1|gp2|gp3|gp4}> <cnt> <enh> <wrrel> <{on|off}>\n"
1056 " : general purpose partition\n"
1057 " MODE - <{check|set|complete}>\n"
1058 " : mode, complete set partitioning completed\n"
1059 " WARNING: Partitioning is a write-once setting once it is set to complete.\n"
1060 " Power cycling is required to initialize partitions after set to complete.\n"
1061 #endif
1062 #ifdef CONFIG_SUPPORT_EMMC_BOOT
1063 "mmc bootbus <dev> <boot_bus_width> <reset_boot_bus_width> <boot_mode>\n"
1064 " - Set the BOOT_BUS_WIDTH field of the specified device\n"
1065 "mmc bootpart-resize <dev> <boot part size MB> <RPMB part size MB>\n"
1066 " - Change sizes of boot and RPMB partitions of specified device\n"
1067 "mmc partconf <dev> [[varname] | [<boot_ack> <boot_partition> <partition_access>]]\n"
1068 " - Show or change the bits of the PARTITION_CONFIG field of the specified device\n"
1069 " If showing the bits, optionally store the boot_partition field into varname\n"
1070 "mmc rst-function <dev> <value>\n"
1071 " - Change the RST_n_FUNCTION field of the specified device\n"
1072 " WARNING: This is a write-once field and 0 / 1 / 2 are the only valid values.\n"
1073 #endif
1074 #if CONFIG_IS_ENABLED(CMD_MMC_RPMB)
1075 "mmc rpmb read addr blk# cnt [address of auth-key] - block size is 256 bytes\n"
1076 "mmc rpmb write addr blk# cnt <address of auth-key> - block size is 256 bytes\n"
1077 "mmc rpmb key <address of auth-key> - program the RPMB authentication key.\n"
1078 "mmc rpmb counter - read the value of the write counter\n"
1079 #endif
1080 "mmc setdsr <value> - set DSR register value\n"
1081 #ifdef CONFIG_CMD_BKOPS_ENABLE
1082 "mmc bkops-enable <dev> - enable background operations handshake on device\n"
1083 " WARNING: This is a write-once setting.\n"
1084 #endif
1085 );
1086
1087 /* Old command kept for compatibility. Same as 'mmc info' */
1088 U_BOOT_CMD(
1089 mmcinfo, 1, 0, do_mmcinfo,
1090 "display MMC info",
1091 "- display info of the current MMC device"
1092 );
1093