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