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