]>
Commit | Line | Data |
---|---|---|
71f95118 WD |
1 | /* |
2 | * (C) Copyright 2003 | |
3 | * Kyle Harris, kharris@nexus-tech.net | |
4 | * | |
5 | * See file CREDITS for list of people who contributed to this | |
6 | * project. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of | |
11 | * the License, or (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
21 | * MA 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #include <common.h> | |
25 | #include <command.h> | |
71f95118 WD |
26 | #include <mmc.h> |
27 | ||
02e22c2d | 28 | static int curr_device = -1; |
ea6ebe21 | 29 | #ifndef CONFIG_GENERIC_MMC |
54841ab5 | 30 | int do_mmc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
71f95118 | 31 | { |
869f6bf4 MK |
32 | int dev; |
33 | ||
47e26b1b | 34 | if (argc < 2) |
4c12eeb8 | 35 | return CMD_RET_USAGE; |
869f6bf4 MK |
36 | |
37 | if (strcmp(argv[1], "init") == 0) { | |
38 | if (argc == 2) { | |
39 | if (curr_device < 0) | |
40 | dev = 1; | |
41 | else | |
42 | dev = curr_device; | |
43 | } else if (argc == 3) { | |
44 | dev = (int)simple_strtoul(argv[2], NULL, 10); | |
45 | } else { | |
4c12eeb8 | 46 | return CMD_RET_USAGE; |
869f6bf4 MK |
47 | } |
48 | ||
49 | if (mmc_legacy_init(dev) != 0) { | |
50 | puts("No MMC card found\n"); | |
51 | return 1; | |
52 | } | |
53 | ||
54 | curr_device = dev; | |
55 | printf("mmc%d is available\n", curr_device); | |
56 | } else if (strcmp(argv[1], "device") == 0) { | |
57 | if (argc == 2) { | |
58 | if (curr_device < 0) { | |
59 | puts("No MMC device available\n"); | |
60 | return 1; | |
61 | } | |
62 | } else if (argc == 3) { | |
63 | dev = (int)simple_strtoul(argv[2], NULL, 10); | |
64 | ||
65 | #ifdef CONFIG_SYS_MMC_SET_DEV | |
66 | if (mmc_set_dev(dev) != 0) | |
67 | return 1; | |
68 | #endif | |
69 | curr_device = dev; | |
70 | } else { | |
4c12eeb8 | 71 | return CMD_RET_USAGE; |
869f6bf4 MK |
72 | } |
73 | ||
74 | printf("mmc%d is current device\n", curr_device); | |
75 | } else { | |
4c12eeb8 | 76 | return CMD_RET_USAGE; |
71f95118 | 77 | } |
869f6bf4 | 78 | |
71f95118 WD |
79 | return 0; |
80 | } | |
81 | ||
0d498393 | 82 | U_BOOT_CMD( |
869f6bf4 MK |
83 | mmc, 3, 1, do_mmc, |
84 | "MMC sub-system", | |
85 | "init [dev] - init MMC sub system\n" | |
a89c33db | 86 | "mmc device [dev] - show or set current device" |
b0fce99b | 87 | ); |
3511b4e2 | 88 | #else /* !CONFIG_GENERIC_MMC */ |
272cc70b | 89 | |
6be95ccf LW |
90 | enum mmc_state { |
91 | MMC_INVALID, | |
92 | MMC_READ, | |
93 | MMC_WRITE, | |
e6f99a56 | 94 | MMC_ERASE, |
6be95ccf | 95 | }; |
272cc70b AF |
96 | static void print_mmcinfo(struct mmc *mmc) |
97 | { | |
98 | printf("Device: %s\n", mmc->name); | |
99 | printf("Manufacturer ID: %x\n", mmc->cid[0] >> 24); | |
100 | printf("OEM: %x\n", (mmc->cid[0] >> 8) & 0xffff); | |
101 | printf("Name: %c%c%c%c%c \n", mmc->cid[0] & 0xff, | |
102 | (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, | |
103 | (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff); | |
104 | ||
105 | printf("Tran Speed: %d\n", mmc->tran_speed); | |
106 | printf("Rd Block Len: %d\n", mmc->read_bl_len); | |
107 | ||
108 | printf("%s version %d.%d\n", IS_SD(mmc) ? "SD" : "MMC", | |
109 | (mmc->version >> 4) & 0xf, mmc->version & 0xf); | |
110 | ||
111 | printf("High Capacity: %s\n", mmc->high_capacity ? "Yes" : "No"); | |
940e0782 MK |
112 | puts("Capacity: "); |
113 | print_size(mmc->capacity, "\n"); | |
272cc70b AF |
114 | |
115 | printf("Bus Width: %d-bit\n", mmc->bus_width); | |
116 | } | |
117 | ||
54841ab5 | 118 | int do_mmcinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
272cc70b AF |
119 | { |
120 | struct mmc *mmc; | |
272cc70b | 121 | |
ea6ebe21 LW |
122 | if (curr_device < 0) { |
123 | if (get_mmc_num() > 0) | |
124 | curr_device = 0; | |
125 | else { | |
126 | puts("No MMC device available\n"); | |
127 | return 1; | |
128 | } | |
129 | } | |
272cc70b | 130 | |
ea6ebe21 | 131 | mmc = find_mmc_device(curr_device); |
272cc70b AF |
132 | |
133 | if (mmc) { | |
134 | mmc_init(mmc); | |
135 | ||
136 | print_mmcinfo(mmc); | |
ea6ebe21 LW |
137 | return 0; |
138 | } else { | |
139 | printf("no mmc device at slot %x\n", curr_device); | |
140 | return 1; | |
272cc70b | 141 | } |
272cc70b AF |
142 | } |
143 | ||
388a29d0 | 144 | U_BOOT_CMD( |
ea6ebe21 | 145 | mmcinfo, 1, 0, do_mmcinfo, |
cc9f607b | 146 | "display MMC info", |
2d941de9 | 147 | " - device number of the device to dislay info of\n" |
a89c33db WD |
148 | "" |
149 | ); | |
272cc70b | 150 | |
54841ab5 | 151 | int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
272cc70b | 152 | { |
6be95ccf LW |
153 | enum mmc_state state; |
154 | ||
ea6ebe21 | 155 | if (argc < 2) |
4c12eeb8 | 156 | return CMD_RET_USAGE; |
272cc70b | 157 | |
ea6ebe21 LW |
158 | if (curr_device < 0) { |
159 | if (get_mmc_num() > 0) | |
160 | curr_device = 0; | |
161 | else { | |
162 | puts("No MMC device available\n"); | |
163 | return 1; | |
164 | } | |
165 | } | |
272cc70b | 166 | |
ea6ebe21 LW |
167 | if (strcmp(argv[1], "rescan") == 0) { |
168 | struct mmc *mmc = find_mmc_device(curr_device); | |
e85649c7 | 169 | |
ea6ebe21 LW |
170 | if (!mmc) { |
171 | printf("no mmc device at slot %x\n", curr_device); | |
172 | return 1; | |
173 | } | |
174 | ||
bc897b1d | 175 | mmc->has_init = 0; |
272cc70b | 176 | |
8fd01b8f MJ |
177 | if (mmc_init(mmc)) |
178 | return 1; | |
179 | else | |
180 | return 0; | |
ea6ebe21 LW |
181 | } else if (strncmp(argv[1], "part", 4) == 0) { |
182 | block_dev_desc_t *mmc_dev; | |
183 | struct mmc *mmc = find_mmc_device(curr_device); | |
184 | ||
185 | if (!mmc) { | |
186 | printf("no mmc device at slot %x\n", curr_device); | |
187 | return 1; | |
188 | } | |
189 | mmc_init(mmc); | |
190 | mmc_dev = mmc_get_dev(curr_device); | |
191 | if (mmc_dev != NULL && | |
192 | mmc_dev->type != DEV_TYPE_UNKNOWN) { | |
193 | print_part(mmc_dev); | |
272cc70b | 194 | return 0; |
ea6ebe21 | 195 | } |
8f3b9642 | 196 | |
ea6ebe21 LW |
197 | puts("get mmc type error!\n"); |
198 | return 1; | |
199 | } else if (strcmp(argv[1], "list") == 0) { | |
200 | print_mmc_devices('\n'); | |
201 | return 0; | |
202 | } else if (strcmp(argv[1], "dev") == 0) { | |
bc897b1d | 203 | int dev, part = -1; |
ea6ebe21 LW |
204 | struct mmc *mmc; |
205 | ||
206 | if (argc == 2) | |
207 | dev = curr_device; | |
208 | else if (argc == 3) | |
209 | dev = simple_strtoul(argv[2], NULL, 10); | |
bc897b1d LW |
210 | else if (argc == 4) { |
211 | dev = (int)simple_strtoul(argv[2], NULL, 10); | |
212 | part = (int)simple_strtoul(argv[3], NULL, 10); | |
213 | if (part > PART_ACCESS_MASK) { | |
214 | printf("#part_num shouldn't be larger" | |
215 | " than %d\n", PART_ACCESS_MASK); | |
216 | return 1; | |
217 | } | |
218 | } else | |
4c12eeb8 | 219 | return CMD_RET_USAGE; |
8f3b9642 | 220 | |
ea6ebe21 LW |
221 | mmc = find_mmc_device(dev); |
222 | if (!mmc) { | |
223 | printf("no mmc device at slot %x\n", dev); | |
8f3b9642 | 224 | return 1; |
272cc70b AF |
225 | } |
226 | ||
bc897b1d LW |
227 | mmc_init(mmc); |
228 | if (part != -1) { | |
229 | int ret; | |
230 | if (mmc->part_config == MMCPART_NOAVAILABLE) { | |
231 | printf("Card doesn't support part_switch\n"); | |
232 | return 1; | |
233 | } | |
234 | ||
235 | if (part != mmc->part_num) { | |
236 | ret = mmc_switch_part(dev, part); | |
237 | if (!ret) | |
238 | mmc->part_num = part; | |
239 | ||
240 | printf("switch to partions #%d, %s\n", | |
241 | part, (!ret) ? "OK" : "ERROR"); | |
242 | } | |
243 | } | |
ea6ebe21 | 244 | curr_device = dev; |
bc897b1d LW |
245 | if (mmc->part_config == MMCPART_NOAVAILABLE) |
246 | printf("mmc%d is current device\n", curr_device); | |
247 | else | |
248 | printf("mmc%d(part %d) is current device\n", | |
249 | curr_device, mmc->part_num); | |
272cc70b | 250 | |
ea6ebe21 | 251 | return 0; |
6be95ccf | 252 | } |
272cc70b | 253 | |
6be95ccf LW |
254 | if (strcmp(argv[1], "read") == 0) |
255 | state = MMC_READ; | |
256 | else if (strcmp(argv[1], "write") == 0) | |
257 | state = MMC_WRITE; | |
e6f99a56 LW |
258 | else if (strcmp(argv[1], "erase") == 0) |
259 | state = MMC_ERASE; | |
6be95ccf LW |
260 | else |
261 | state = MMC_INVALID; | |
272cc70b | 262 | |
6be95ccf LW |
263 | if (state != MMC_INVALID) { |
264 | struct mmc *mmc = find_mmc_device(curr_device); | |
e6f99a56 LW |
265 | int idx = 2; |
266 | u32 blk, cnt, n; | |
267 | void *addr; | |
268 | ||
269 | if (state != MMC_ERASE) { | |
270 | addr = (void *)simple_strtoul(argv[idx], NULL, 16); | |
271 | ++idx; | |
272 | } else | |
273 | addr = 0; | |
274 | blk = simple_strtoul(argv[idx], NULL, 16); | |
275 | cnt = simple_strtoul(argv[idx + 1], NULL, 16); | |
272cc70b | 276 | |
ea6ebe21 LW |
277 | if (!mmc) { |
278 | printf("no mmc device at slot %x\n", curr_device); | |
279 | return 1; | |
280 | } | |
e85649c7 | 281 | |
6be95ccf LW |
282 | printf("\nMMC %s: dev # %d, block # %d, count %d ... ", |
283 | argv[1], curr_device, blk, cnt); | |
272cc70b | 284 | |
ea6ebe21 | 285 | mmc_init(mmc); |
272cc70b | 286 | |
6be95ccf LW |
287 | switch (state) { |
288 | case MMC_READ: | |
289 | n = mmc->block_dev.block_read(curr_device, blk, | |
290 | cnt, addr); | |
291 | /* flush cache after read */ | |
292 | flush_cache((ulong)addr, cnt * 512); /* FIXME */ | |
293 | break; | |
294 | case MMC_WRITE: | |
295 | n = mmc->block_dev.block_write(curr_device, blk, | |
296 | cnt, addr); | |
297 | break; | |
e6f99a56 LW |
298 | case MMC_ERASE: |
299 | n = mmc->block_dev.block_erase(curr_device, blk, cnt); | |
300 | break; | |
6be95ccf LW |
301 | default: |
302 | BUG(); | |
303 | } | |
272cc70b | 304 | |
6be95ccf LW |
305 | printf("%d blocks %s: %s\n", |
306 | n, argv[1], (n == cnt) ? "OK" : "ERROR"); | |
ea6ebe21 | 307 | return (n == cnt) ? 0 : 1; |
272cc70b | 308 | } |
ea6ebe21 | 309 | |
4c12eeb8 | 310 | return CMD_RET_USAGE; |
272cc70b AF |
311 | } |
312 | ||
313 | U_BOOT_CMD( | |
314 | mmc, 6, 1, do_mmcops, | |
852dbfdd | 315 | "MMC sub system", |
ea6ebe21 LW |
316 | "read addr blk# cnt\n" |
317 | "mmc write addr blk# cnt\n" | |
e6f99a56 | 318 | "mmc erase blk# cnt\n" |
ea6ebe21 LW |
319 | "mmc rescan\n" |
320 | "mmc part - lists available partition on current mmc device\n" | |
bc897b1d | 321 | "mmc dev [dev] [part] - show or set current mmc device [partition]\n" |
a89c33db | 322 | "mmc list - lists available devices"); |
3511b4e2 | 323 | #endif |