]>
Commit | Line | Data |
---|---|---|
affae2bf WD |
1 | /* |
2 | * (C) Copyright 2001 | |
3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
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> | |
26 | #include <ide.h> | |
735dd97b | 27 | #include <part.h> |
affae2bf WD |
28 | |
29 | #undef PART_DEBUG | |
30 | ||
31 | #ifdef PART_DEBUG | |
32 | #define PRINTF(fmt,args...) printf (fmt ,##args) | |
33 | #else | |
34 | #define PRINTF(fmt,args...) | |
35 | #endif | |
36 | ||
cde5c64d | 37 | #if (defined(CONFIG_CMD_IDE) || \ |
c7057b52 | 38 | defined(CONFIG_CMD_SATA) || \ |
cde5c64d JL |
39 | defined(CONFIG_CMD_SCSI) || \ |
40 | defined(CONFIG_CMD_USB) || \ | |
735dd97b GL |
41 | defined(CONFIG_MMC) || \ |
42 | defined(CONFIG_SYSTEMACE) ) | |
43 | ||
44 | struct block_drvr { | |
45 | char *name; | |
46 | block_dev_desc_t* (*get_dev)(int dev); | |
47 | }; | |
48 | ||
49 | static const struct block_drvr block_drvr[] = { | |
cde5c64d | 50 | #if defined(CONFIG_CMD_IDE) |
735dd97b GL |
51 | { .name = "ide", .get_dev = ide_get_dev, }, |
52 | #endif | |
c7057b52 DL |
53 | #if defined(CONFIG_CMD_SATA) |
54 | {.name = "sata", .get_dev = sata_get_dev, }, | |
55 | #endif | |
cde5c64d | 56 | #if defined(CONFIG_CMD_SCSI) |
735dd97b GL |
57 | { .name = "scsi", .get_dev = scsi_get_dev, }, |
58 | #endif | |
cde5c64d | 59 | #if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE) |
735dd97b GL |
60 | { .name = "usb", .get_dev = usb_stor_get_dev, }, |
61 | #endif | |
62 | #if defined(CONFIG_MMC) | |
63 | { .name = "mmc", .get_dev = mmc_get_dev, }, | |
64 | #endif | |
65 | #if defined(CONFIG_SYSTEMACE) | |
66 | { .name = "ace", .get_dev = systemace_get_dev, }, | |
67 | #endif | |
68 | { }, | |
69 | }; | |
70 | ||
751bb571 | 71 | DECLARE_GLOBAL_DATA_PTR; |
751bb571 | 72 | |
99d2c205 | 73 | block_dev_desc_t *get_dev(const char *ifname, int dev) |
735dd97b GL |
74 | { |
75 | const struct block_drvr *drvr = block_drvr; | |
6c7cac8c | 76 | block_dev_desc_t* (*reloc_get_dev)(int dev); |
23090dac | 77 | char *name; |
735dd97b | 78 | |
7e71dc68 TK |
79 | if (!ifname) |
80 | return NULL; | |
81 | ||
23090dac | 82 | name = drvr->name; |
2e5167cc | 83 | #ifdef CONFIG_NEEDS_MANUAL_RELOC |
23090dac HS |
84 | name += gd->reloc_off; |
85 | #endif | |
b16aadf4 | 86 | while (drvr->name) { |
23090dac | 87 | name = drvr->name; |
521af04d | 88 | reloc_get_dev = drvr->get_dev; |
2e5167cc | 89 | #ifdef CONFIG_NEEDS_MANUAL_RELOC |
23090dac | 90 | name += gd->reloc_off; |
521af04d PT |
91 | reloc_get_dev += gd->reloc_off; |
92 | #endif | |
23090dac | 93 | if (strncmp(ifname, name, strlen(name)) == 0) |
751bb571 | 94 | return reloc_get_dev(dev); |
735dd97b GL |
95 | drvr++; |
96 | } | |
97 | return NULL; | |
98 | } | |
99 | #else | |
99d2c205 | 100 | block_dev_desc_t *get_dev(const char *ifname, int dev) |
735dd97b GL |
101 | { |
102 | return NULL; | |
103 | } | |
104 | #endif | |
105 | ||
cde5c64d | 106 | #if (defined(CONFIG_CMD_IDE) || \ |
c7057b52 | 107 | defined(CONFIG_CMD_SATA) || \ |
cde5c64d JL |
108 | defined(CONFIG_CMD_SCSI) || \ |
109 | defined(CONFIG_CMD_USB) || \ | |
1968e615 WD |
110 | defined(CONFIG_MMC) || \ |
111 | defined(CONFIG_SYSTEMACE) ) | |
affae2bf WD |
112 | |
113 | /* ------------------------------------------------------------------------- */ | |
114 | /* | |
115 | * reports device info to the user | |
116 | */ | |
69a2a4d9 | 117 | |
42dfe7a1 | 118 | #ifdef CONFIG_LBA48 |
69a2a4d9 | 119 | typedef uint64_t lba512_t; |
c40b2956 | 120 | #else |
69a2a4d9 | 121 | typedef lbaint_t lba512_t; |
c40b2956 | 122 | #endif |
affae2bf | 123 | |
69a2a4d9 ST |
124 | /* |
125 | * Overflowless variant of (block_count * mul_by / div_by) | |
126 | * when div_by > mul_by | |
127 | */ | |
128 | static lba512_t lba512_muldiv (lba512_t block_count, lba512_t mul_by, lba512_t div_by) | |
129 | { | |
130 | lba512_t bc_quot, bc_rem; | |
131 | ||
132 | /* x * m / d == x / d * m + (x % d) * m / d */ | |
133 | bc_quot = block_count / div_by; | |
134 | bc_rem = block_count - div_by * bc_quot; | |
135 | return bc_quot * mul_by + (bc_rem * mul_by) / div_by; | |
136 | } | |
137 | ||
138 | void dev_print (block_dev_desc_t *dev_desc) | |
139 | { | |
140 | lba512_t lba512; /* number of blocks if 512bytes block size */ | |
141 | ||
af75a45d WD |
142 | if (dev_desc->type == DEV_TYPE_UNKNOWN) { |
143 | puts ("not available\n"); | |
144 | return; | |
145 | } | |
146 | ||
8ec6e332 | 147 | switch (dev_desc->if_type) { |
574b3195 DZ |
148 | case IF_TYPE_SCSI: |
149 | printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n", | |
150 | dev_desc->target,dev_desc->lun, | |
affae2bf | 151 | dev_desc->vendor, |
574b3195 DZ |
152 | dev_desc->product, |
153 | dev_desc->revision); | |
154 | break; | |
6e24a1eb | 155 | case IF_TYPE_ATAPI: |
574b3195 DZ |
156 | case IF_TYPE_IDE: |
157 | case IF_TYPE_SATA: | |
c7057b52 DL |
158 | printf ("Model: %s Firm: %s Ser#: %s\n", |
159 | dev_desc->vendor, | |
160 | dev_desc->revision, | |
161 | dev_desc->product); | |
574b3195 | 162 | break; |
6e24a1eb RB |
163 | case IF_TYPE_SD: |
164 | case IF_TYPE_MMC: | |
47bebe34 NCL |
165 | case IF_TYPE_USB: |
166 | printf ("Vendor: %s Rev: %s Prod: %s\n", | |
167 | dev_desc->vendor, | |
168 | dev_desc->revision, | |
169 | dev_desc->product); | |
170 | break; | |
6e24a1eb RB |
171 | case IF_TYPE_DOC: |
172 | puts("device type DOC\n"); | |
173 | return; | |
8ec6e332 | 174 | case IF_TYPE_UNKNOWN: |
6e24a1eb RB |
175 | puts("device type unknown\n"); |
176 | return; | |
574b3195 | 177 | default: |
6e24a1eb | 178 | printf("Unhandled device type: %i\n", dev_desc->if_type); |
574b3195 | 179 | return; |
affae2bf WD |
180 | } |
181 | puts (" Type: "); | |
182 | if (dev_desc->removable) | |
183 | puts ("Removable "); | |
184 | switch (dev_desc->type & 0x1F) { | |
726c0f1e DZ |
185 | case DEV_TYPE_HARDDISK: |
186 | puts ("Hard Disk"); | |
187 | break; | |
188 | case DEV_TYPE_CDROM: | |
189 | puts ("CD ROM"); | |
190 | break; | |
191 | case DEV_TYPE_OPDISK: | |
192 | puts ("Optical Device"); | |
193 | break; | |
194 | case DEV_TYPE_TAPE: | |
195 | puts ("Tape"); | |
196 | break; | |
197 | default: | |
198 | printf ("# %02X #", dev_desc->type & 0x1F); | |
199 | break; | |
affae2bf WD |
200 | } |
201 | puts ("\n"); | |
202 | if ((dev_desc->lba * dev_desc->blksz)>0L) { | |
203 | ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem; | |
c40b2956 | 204 | lbaint_t lba; |
6e592385 WD |
205 | |
206 | lba = dev_desc->lba; | |
affae2bf | 207 | |
c40b2956 | 208 | lba512 = (lba * (dev_desc->blksz/512)); |
affae2bf | 209 | /* round to 1 digit */ |
69a2a4d9 ST |
210 | mb = lba512_muldiv(lba512, 10, 2048); /* 2048 = (1024 * 1024) / 512 MB */ |
211 | ||
affae2bf WD |
212 | mb_quot = mb / 10; |
213 | mb_rem = mb - (10 * mb_quot); | |
214 | ||
215 | gb = mb / 1024; | |
216 | gb_quot = gb / 10; | |
217 | gb_rem = gb - (10 * gb_quot); | |
42dfe7a1 | 218 | #ifdef CONFIG_LBA48 |
6e592385 | 219 | if (dev_desc->lba48) |
c40b2956 WD |
220 | printf (" Supports 48-bit addressing\n"); |
221 | #endif | |
4b142feb | 222 | #if defined(CONFIG_SYS_64BIT_LBA) |
6c6166f5 | 223 | printf (" Capacity: %ld.%ld MB = %ld.%ld GB (%Ld x %ld)\n", |
c40b2956 WD |
224 | mb_quot, mb_rem, |
225 | gb_quot, gb_rem, | |
226 | lba, | |
227 | dev_desc->blksz); | |
228 | #else | |
affae2bf WD |
229 | printf (" Capacity: %ld.%ld MB = %ld.%ld GB (%ld x %ld)\n", |
230 | mb_quot, mb_rem, | |
231 | gb_quot, gb_rem, | |
c40b2956 | 232 | (ulong)lba, |
affae2bf | 233 | dev_desc->blksz); |
c40b2956 | 234 | #endif |
affae2bf WD |
235 | } else { |
236 | puts (" Capacity: not available\n"); | |
237 | } | |
238 | } | |
b3aff0cb | 239 | #endif |
affae2bf | 240 | |
cde5c64d | 241 | #if (defined(CONFIG_CMD_IDE) || \ |
c7057b52 | 242 | defined(CONFIG_CMD_SATA) || \ |
cde5c64d JL |
243 | defined(CONFIG_CMD_SCSI) || \ |
244 | defined(CONFIG_CMD_USB) || \ | |
7fac3f69 | 245 | defined(CONFIG_MMC) || \ |
75eb82ec | 246 | defined(CONFIG_SYSTEMACE) ) |
affae2bf | 247 | |
affae2bf WD |
248 | #if defined(CONFIG_MAC_PARTITION) || \ |
249 | defined(CONFIG_DOS_PARTITION) || \ | |
c7de829c | 250 | defined(CONFIG_ISO_PARTITION) || \ |
07f3d789 | 251 | defined(CONFIG_AMIGA_PARTITION) || \ |
252 | defined(CONFIG_EFI_PARTITION) | |
affae2bf WD |
253 | |
254 | void init_part (block_dev_desc_t * dev_desc) | |
255 | { | |
256 | #ifdef CONFIG_ISO_PARTITION | |
257 | if (test_part_iso(dev_desc) == 0) { | |
258 | dev_desc->part_type = PART_TYPE_ISO; | |
259 | return; | |
260 | } | |
261 | #endif | |
262 | ||
263 | #ifdef CONFIG_MAC_PARTITION | |
264 | if (test_part_mac(dev_desc) == 0) { | |
265 | dev_desc->part_type = PART_TYPE_MAC; | |
266 | return; | |
267 | } | |
268 | #endif | |
269 | ||
07f3d789 | 270 | /* must be placed before DOS partition detection */ |
271 | #ifdef CONFIG_EFI_PARTITION | |
272 | if (test_part_efi(dev_desc) == 0) { | |
273 | dev_desc->part_type = PART_TYPE_EFI; | |
274 | return; | |
275 | } | |
276 | #endif | |
277 | ||
affae2bf WD |
278 | #ifdef CONFIG_DOS_PARTITION |
279 | if (test_part_dos(dev_desc) == 0) { | |
280 | dev_desc->part_type = PART_TYPE_DOS; | |
281 | return; | |
282 | } | |
283 | #endif | |
c7de829c WD |
284 | |
285 | #ifdef CONFIG_AMIGA_PARTITION | |
286 | if (test_part_amiga(dev_desc) == 0) { | |
287 | dev_desc->part_type = PART_TYPE_AMIGA; | |
288 | return; | |
289 | } | |
290 | #endif | |
99d2c205 | 291 | dev_desc->part_type = PART_TYPE_UNKNOWN; |
affae2bf WD |
292 | } |
293 | ||
294 | ||
affae2bf WD |
295 | static void print_part_header (const char *type, block_dev_desc_t * dev_desc) |
296 | { | |
297 | puts ("\nPartition Map for "); | |
298 | switch (dev_desc->if_type) { | |
726c0f1e DZ |
299 | case IF_TYPE_IDE: |
300 | puts ("IDE"); | |
301 | break; | |
302 | case IF_TYPE_SATA: | |
303 | puts ("SATA"); | |
304 | break; | |
305 | case IF_TYPE_SCSI: | |
306 | puts ("SCSI"); | |
307 | break; | |
308 | case IF_TYPE_ATAPI: | |
309 | puts ("ATAPI"); | |
310 | break; | |
311 | case IF_TYPE_USB: | |
312 | puts ("USB"); | |
313 | break; | |
314 | case IF_TYPE_DOC: | |
315 | puts ("DOC"); | |
316 | break; | |
8f3b9642 LW |
317 | case IF_TYPE_MMC: |
318 | puts ("MMC"); | |
319 | break; | |
726c0f1e DZ |
320 | default: |
321 | puts ("UNKNOWN"); | |
322 | break; | |
affae2bf WD |
323 | } |
324 | printf (" device %d -- Partition Type: %s\n\n", | |
325 | dev_desc->dev, type); | |
326 | } | |
327 | ||
328 | void print_part (block_dev_desc_t * dev_desc) | |
329 | { | |
330 | ||
331 | switch (dev_desc->part_type) { | |
332 | #ifdef CONFIG_MAC_PARTITION | |
333 | case PART_TYPE_MAC: | |
334 | PRINTF ("## Testing for valid MAC partition ##\n"); | |
335 | print_part_header ("MAC", dev_desc); | |
336 | print_part_mac (dev_desc); | |
337 | return; | |
338 | #endif | |
339 | #ifdef CONFIG_DOS_PARTITION | |
340 | case PART_TYPE_DOS: | |
341 | PRINTF ("## Testing for valid DOS partition ##\n"); | |
342 | print_part_header ("DOS", dev_desc); | |
343 | print_part_dos (dev_desc); | |
344 | return; | |
345 | #endif | |
346 | ||
347 | #ifdef CONFIG_ISO_PARTITION | |
348 | case PART_TYPE_ISO: | |
349 | PRINTF ("## Testing for valid ISO Boot partition ##\n"); | |
350 | print_part_header ("ISO", dev_desc); | |
351 | print_part_iso (dev_desc); | |
352 | return; | |
353 | #endif | |
c7de829c WD |
354 | |
355 | #ifdef CONFIG_AMIGA_PARTITION | |
356 | case PART_TYPE_AMIGA: | |
357 | PRINTF ("## Testing for a valid Amiga partition ##\n"); | |
358 | print_part_header ("AMIGA", dev_desc); | |
359 | print_part_amiga (dev_desc); | |
360 | return; | |
361 | #endif | |
07f3d789 | 362 | |
363 | #ifdef CONFIG_EFI_PARTITION | |
364 | case PART_TYPE_EFI: | |
365 | PRINTF ("## Testing for valid EFI partition ##\n"); | |
366 | print_part_header ("EFI", dev_desc); | |
367 | print_part_efi (dev_desc); | |
368 | return; | |
369 | #endif | |
affae2bf WD |
370 | } |
371 | puts ("## Unknown partition table\n"); | |
372 | } | |
373 | ||
374 | ||
07f3d789 | 375 | #else /* neither MAC nor DOS nor ISO nor AMIGA nor EFI partition configured */ |
725671cc | 376 | # error neither CONFIG_MAC_PARTITION nor CONFIG_DOS_PARTITION |
07f3d789 | 377 | # error nor CONFIG_ISO_PARTITION nor CONFIG_AMIGA_PARTITION |
378 | # error nor CONFIG_EFI_PARTITION configured! | |
affae2bf WD |
379 | #endif |
380 | ||
cde5c64d | 381 | #endif |
2f501646 SW |
382 | |
383 | int get_partition_info(block_dev_desc_t *dev_desc, int part | |
384 | , disk_partition_t *info) | |
385 | { | |
386 | #if defined(CONFIG_CMD_IDE) || \ | |
387 | defined(CONFIG_CMD_SATA) || \ | |
388 | defined(CONFIG_CMD_SCSI) || \ | |
389 | defined(CONFIG_CMD_USB) || \ | |
390 | defined(CONFIG_MMC) || \ | |
391 | defined(CONFIG_SYSTEMACE) | |
392 | ||
393 | switch (dev_desc->part_type) { | |
394 | #ifdef CONFIG_MAC_PARTITION | |
395 | case PART_TYPE_MAC: | |
396 | if (get_partition_info_mac(dev_desc, part, info) == 0) { | |
397 | PRINTF("## Valid MAC partition found ##\n"); | |
398 | return 0; | |
399 | } | |
400 | break; | |
401 | #endif | |
402 | ||
403 | #ifdef CONFIG_DOS_PARTITION | |
404 | case PART_TYPE_DOS: | |
405 | if (get_partition_info_dos(dev_desc, part, info) == 0) { | |
406 | PRINTF("## Valid DOS partition found ##\n"); | |
407 | return 0; | |
408 | } | |
409 | break; | |
410 | #endif | |
411 | ||
412 | #ifdef CONFIG_ISO_PARTITION | |
413 | case PART_TYPE_ISO: | |
414 | if (get_partition_info_iso(dev_desc, part, info) == 0) { | |
415 | PRINTF("## Valid ISO boot partition found ##\n"); | |
416 | return 0; | |
417 | } | |
418 | break; | |
419 | #endif | |
420 | ||
421 | #ifdef CONFIG_AMIGA_PARTITION | |
422 | case PART_TYPE_AMIGA: | |
423 | if (get_partition_info_amiga(dev_desc, part, info) == 0) { | |
424 | PRINTF("## Valid Amiga partition found ##\n"); | |
425 | return 0; | |
426 | } | |
427 | break; | |
428 | #endif | |
429 | ||
430 | #ifdef CONFIG_EFI_PARTITION | |
431 | case PART_TYPE_EFI: | |
432 | if (get_partition_info_efi(dev_desc, part, info) == 0) { | |
433 | PRINTF("## Valid EFI partition found ##\n"); | |
434 | return 0; | |
435 | } | |
436 | break; | |
437 | #endif | |
438 | default: | |
439 | break; | |
440 | } | |
441 | #endif | |
442 | ||
443 | return -1; | |
444 | } | |
99d2c205 | 445 | |
2023e608 SW |
446 | int get_device(const char *ifname, const char *dev_str, |
447 | block_dev_desc_t **dev_desc) | |
448 | { | |
449 | char *ep; | |
450 | int dev; | |
451 | ||
452 | dev = simple_strtoul(dev_str, &ep, 16); | |
453 | if (*ep) { | |
454 | printf("** Bad device specification %s %s **\n", | |
455 | ifname, dev_str); | |
456 | return -1; | |
457 | } | |
458 | ||
459 | *dev_desc = get_dev(ifname, dev); | |
460 | if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) { | |
461 | printf("** Bad device %s %s **\n", ifname, dev_str); | |
462 | return -1; | |
463 | } | |
464 | ||
465 | return dev; | |
466 | } | |
467 | ||
99d2c205 RH |
468 | int get_device_and_partition(const char *ifname, const char *dev_str, |
469 | block_dev_desc_t **dev_desc, | |
470 | disk_partition_t *info) | |
471 | { | |
472 | int ret; | |
473 | char *ep; | |
474 | int dev; | |
475 | block_dev_desc_t *desc; | |
476 | int part = 0; | |
477 | char *part_str; | |
478 | ||
479 | if (dev_str) | |
480 | dev = simple_strtoul(dev_str, &ep, 16); | |
481 | ||
482 | if (!dev_str || (dev_str == ep)) { | |
483 | dev_str = getenv("bootdevice"); | |
484 | if (dev_str) | |
485 | dev = simple_strtoul(dev_str, &ep, 16); | |
486 | if (!dev_str || (dev_str == ep)) | |
487 | goto err; | |
488 | } | |
489 | ||
490 | desc = get_dev(ifname, dev); | |
491 | if (!desc || (desc->type == DEV_TYPE_UNKNOWN)) | |
492 | goto err; | |
493 | ||
494 | if (desc->part_type == PART_TYPE_UNKNOWN) { | |
495 | /* disk doesn't use partition table */ | |
496 | if (!desc->lba) { | |
497 | printf("**Bad disk size - %s %d:0 **\n", ifname, dev); | |
498 | return -1; | |
499 | } | |
500 | info->start = 0; | |
501 | info->size = desc->lba; | |
502 | info->blksz = desc->blksz; | |
503 | ||
504 | *dev_desc = desc; | |
505 | return 0; | |
506 | } | |
507 | ||
508 | part_str = strchr(dev_str, ':'); | |
509 | if (part_str) | |
510 | part = (int)simple_strtoul(++part_str, NULL, 16); | |
511 | ||
512 | ret = get_partition_info(desc, part, info); | |
513 | if (ret) { | |
514 | printf("** Invalid partition %d, use `dev[:part]' **\n", part); | |
515 | return -1; | |
516 | } | |
517 | if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) { | |
518 | printf("** Invalid partition type \"%.32s\"" | |
519 | " (expect \"" BOOT_PART_TYPE "\")\n", | |
520 | info->type); | |
521 | return -1; | |
522 | } | |
523 | ||
524 | *dev_desc = desc; | |
525 | return part; | |
526 | ||
527 | err: | |
528 | puts("** Invalid boot device, use `dev[:part]' **\n"); | |
529 | return -1; | |
530 | } |