]>
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> | |
10a37fd7 | 27 | #include <malloc.h> |
735dd97b | 28 | #include <part.h> |
affae2bf WD |
29 | |
30 | #undef PART_DEBUG | |
31 | ||
32 | #ifdef PART_DEBUG | |
33 | #define PRINTF(fmt,args...) printf (fmt ,##args) | |
34 | #else | |
35 | #define PRINTF(fmt,args...) | |
36 | #endif | |
37 | ||
735dd97b GL |
38 | struct block_drvr { |
39 | char *name; | |
40 | block_dev_desc_t* (*get_dev)(int dev); | |
41 | }; | |
42 | ||
43 | static const struct block_drvr block_drvr[] = { | |
cde5c64d | 44 | #if defined(CONFIG_CMD_IDE) |
735dd97b GL |
45 | { .name = "ide", .get_dev = ide_get_dev, }, |
46 | #endif | |
c7057b52 DL |
47 | #if defined(CONFIG_CMD_SATA) |
48 | {.name = "sata", .get_dev = sata_get_dev, }, | |
49 | #endif | |
cde5c64d | 50 | #if defined(CONFIG_CMD_SCSI) |
735dd97b GL |
51 | { .name = "scsi", .get_dev = scsi_get_dev, }, |
52 | #endif | |
cde5c64d | 53 | #if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE) |
735dd97b GL |
54 | { .name = "usb", .get_dev = usb_stor_get_dev, }, |
55 | #endif | |
56 | #if defined(CONFIG_MMC) | |
57 | { .name = "mmc", .get_dev = mmc_get_dev, }, | |
58 | #endif | |
59 | #if defined(CONFIG_SYSTEMACE) | |
60 | { .name = "ace", .get_dev = systemace_get_dev, }, | |
61 | #endif | |
62 | { }, | |
63 | }; | |
64 | ||
751bb571 | 65 | DECLARE_GLOBAL_DATA_PTR; |
751bb571 | 66 | |
0c9c8fb5 | 67 | #ifdef HAVE_BLOCK_DEVICE |
99d2c205 | 68 | block_dev_desc_t *get_dev(const char *ifname, int dev) |
735dd97b GL |
69 | { |
70 | const struct block_drvr *drvr = block_drvr; | |
6c7cac8c | 71 | block_dev_desc_t* (*reloc_get_dev)(int dev); |
23090dac | 72 | char *name; |
735dd97b | 73 | |
7e71dc68 TK |
74 | if (!ifname) |
75 | return NULL; | |
76 | ||
23090dac | 77 | name = drvr->name; |
2e5167cc | 78 | #ifdef CONFIG_NEEDS_MANUAL_RELOC |
23090dac HS |
79 | name += gd->reloc_off; |
80 | #endif | |
b16aadf4 | 81 | while (drvr->name) { |
23090dac | 82 | name = drvr->name; |
521af04d | 83 | reloc_get_dev = drvr->get_dev; |
2e5167cc | 84 | #ifdef CONFIG_NEEDS_MANUAL_RELOC |
23090dac | 85 | name += gd->reloc_off; |
521af04d PT |
86 | reloc_get_dev += gd->reloc_off; |
87 | #endif | |
23090dac | 88 | if (strncmp(ifname, name, strlen(name)) == 0) |
751bb571 | 89 | return reloc_get_dev(dev); |
735dd97b GL |
90 | drvr++; |
91 | } | |
92 | return NULL; | |
93 | } | |
94 | #else | |
99d2c205 | 95 | block_dev_desc_t *get_dev(const char *ifname, int dev) |
735dd97b GL |
96 | { |
97 | return NULL; | |
98 | } | |
99 | #endif | |
100 | ||
0c9c8fb5 | 101 | #ifdef HAVE_BLOCK_DEVICE |
affae2bf WD |
102 | |
103 | /* ------------------------------------------------------------------------- */ | |
104 | /* | |
105 | * reports device info to the user | |
106 | */ | |
69a2a4d9 | 107 | |
42dfe7a1 | 108 | #ifdef CONFIG_LBA48 |
69a2a4d9 | 109 | typedef uint64_t lba512_t; |
c40b2956 | 110 | #else |
69a2a4d9 | 111 | typedef lbaint_t lba512_t; |
c40b2956 | 112 | #endif |
affae2bf | 113 | |
69a2a4d9 ST |
114 | /* |
115 | * Overflowless variant of (block_count * mul_by / div_by) | |
116 | * when div_by > mul_by | |
117 | */ | |
118 | static lba512_t lba512_muldiv (lba512_t block_count, lba512_t mul_by, lba512_t div_by) | |
119 | { | |
120 | lba512_t bc_quot, bc_rem; | |
121 | ||
122 | /* x * m / d == x / d * m + (x % d) * m / d */ | |
123 | bc_quot = block_count / div_by; | |
124 | bc_rem = block_count - div_by * bc_quot; | |
125 | return bc_quot * mul_by + (bc_rem * mul_by) / div_by; | |
126 | } | |
127 | ||
128 | void dev_print (block_dev_desc_t *dev_desc) | |
129 | { | |
130 | lba512_t lba512; /* number of blocks if 512bytes block size */ | |
131 | ||
af75a45d WD |
132 | if (dev_desc->type == DEV_TYPE_UNKNOWN) { |
133 | puts ("not available\n"); | |
134 | return; | |
135 | } | |
136 | ||
8ec6e332 | 137 | switch (dev_desc->if_type) { |
574b3195 DZ |
138 | case IF_TYPE_SCSI: |
139 | printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n", | |
140 | dev_desc->target,dev_desc->lun, | |
affae2bf | 141 | dev_desc->vendor, |
574b3195 DZ |
142 | dev_desc->product, |
143 | dev_desc->revision); | |
144 | break; | |
6e24a1eb | 145 | case IF_TYPE_ATAPI: |
574b3195 DZ |
146 | case IF_TYPE_IDE: |
147 | case IF_TYPE_SATA: | |
c7057b52 DL |
148 | printf ("Model: %s Firm: %s Ser#: %s\n", |
149 | dev_desc->vendor, | |
150 | dev_desc->revision, | |
151 | dev_desc->product); | |
574b3195 | 152 | break; |
6e24a1eb RB |
153 | case IF_TYPE_SD: |
154 | case IF_TYPE_MMC: | |
47bebe34 NCL |
155 | case IF_TYPE_USB: |
156 | printf ("Vendor: %s Rev: %s Prod: %s\n", | |
157 | dev_desc->vendor, | |
158 | dev_desc->revision, | |
159 | dev_desc->product); | |
160 | break; | |
6e24a1eb RB |
161 | case IF_TYPE_DOC: |
162 | puts("device type DOC\n"); | |
163 | return; | |
8ec6e332 | 164 | case IF_TYPE_UNKNOWN: |
6e24a1eb RB |
165 | puts("device type unknown\n"); |
166 | return; | |
574b3195 | 167 | default: |
6e24a1eb | 168 | printf("Unhandled device type: %i\n", dev_desc->if_type); |
574b3195 | 169 | return; |
affae2bf WD |
170 | } |
171 | puts (" Type: "); | |
172 | if (dev_desc->removable) | |
173 | puts ("Removable "); | |
174 | switch (dev_desc->type & 0x1F) { | |
726c0f1e DZ |
175 | case DEV_TYPE_HARDDISK: |
176 | puts ("Hard Disk"); | |
177 | break; | |
178 | case DEV_TYPE_CDROM: | |
179 | puts ("CD ROM"); | |
180 | break; | |
181 | case DEV_TYPE_OPDISK: | |
182 | puts ("Optical Device"); | |
183 | break; | |
184 | case DEV_TYPE_TAPE: | |
185 | puts ("Tape"); | |
186 | break; | |
187 | default: | |
188 | printf ("# %02X #", dev_desc->type & 0x1F); | |
189 | break; | |
affae2bf WD |
190 | } |
191 | puts ("\n"); | |
33699df1 | 192 | if (dev_desc->lba > 0L && dev_desc->blksz > 0L) { |
affae2bf | 193 | ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem; |
c40b2956 | 194 | lbaint_t lba; |
6e592385 WD |
195 | |
196 | lba = dev_desc->lba; | |
affae2bf | 197 | |
c40b2956 | 198 | lba512 = (lba * (dev_desc->blksz/512)); |
affae2bf | 199 | /* round to 1 digit */ |
69a2a4d9 ST |
200 | mb = lba512_muldiv(lba512, 10, 2048); /* 2048 = (1024 * 1024) / 512 MB */ |
201 | ||
affae2bf WD |
202 | mb_quot = mb / 10; |
203 | mb_rem = mb - (10 * mb_quot); | |
204 | ||
205 | gb = mb / 1024; | |
206 | gb_quot = gb / 10; | |
207 | gb_rem = gb - (10 * gb_quot); | |
42dfe7a1 | 208 | #ifdef CONFIG_LBA48 |
6e592385 | 209 | if (dev_desc->lba48) |
c40b2956 WD |
210 | printf (" Supports 48-bit addressing\n"); |
211 | #endif | |
4b142feb | 212 | #if defined(CONFIG_SYS_64BIT_LBA) |
6c6166f5 | 213 | printf (" Capacity: %ld.%ld MB = %ld.%ld GB (%Ld x %ld)\n", |
c40b2956 WD |
214 | mb_quot, mb_rem, |
215 | gb_quot, gb_rem, | |
216 | lba, | |
217 | dev_desc->blksz); | |
218 | #else | |
affae2bf WD |
219 | printf (" Capacity: %ld.%ld MB = %ld.%ld GB (%ld x %ld)\n", |
220 | mb_quot, mb_rem, | |
221 | gb_quot, gb_rem, | |
c40b2956 | 222 | (ulong)lba, |
affae2bf | 223 | dev_desc->blksz); |
c40b2956 | 224 | #endif |
affae2bf WD |
225 | } else { |
226 | puts (" Capacity: not available\n"); | |
227 | } | |
228 | } | |
b3aff0cb | 229 | #endif |
affae2bf | 230 | |
0c9c8fb5 | 231 | #ifdef HAVE_BLOCK_DEVICE |
affae2bf WD |
232 | |
233 | void init_part (block_dev_desc_t * dev_desc) | |
234 | { | |
235 | #ifdef CONFIG_ISO_PARTITION | |
236 | if (test_part_iso(dev_desc) == 0) { | |
237 | dev_desc->part_type = PART_TYPE_ISO; | |
238 | return; | |
239 | } | |
240 | #endif | |
241 | ||
242 | #ifdef CONFIG_MAC_PARTITION | |
243 | if (test_part_mac(dev_desc) == 0) { | |
244 | dev_desc->part_type = PART_TYPE_MAC; | |
245 | return; | |
246 | } | |
247 | #endif | |
248 | ||
07f3d789 | 249 | /* must be placed before DOS partition detection */ |
250 | #ifdef CONFIG_EFI_PARTITION | |
251 | if (test_part_efi(dev_desc) == 0) { | |
252 | dev_desc->part_type = PART_TYPE_EFI; | |
253 | return; | |
254 | } | |
255 | #endif | |
256 | ||
affae2bf WD |
257 | #ifdef CONFIG_DOS_PARTITION |
258 | if (test_part_dos(dev_desc) == 0) { | |
259 | dev_desc->part_type = PART_TYPE_DOS; | |
260 | return; | |
261 | } | |
262 | #endif | |
c7de829c WD |
263 | |
264 | #ifdef CONFIG_AMIGA_PARTITION | |
265 | if (test_part_amiga(dev_desc) == 0) { | |
266 | dev_desc->part_type = PART_TYPE_AMIGA; | |
267 | return; | |
268 | } | |
269 | #endif | |
99d2c205 | 270 | dev_desc->part_type = PART_TYPE_UNKNOWN; |
affae2bf WD |
271 | } |
272 | ||
273 | ||
0c9c8fb5 GB |
274 | #if defined(CONFIG_MAC_PARTITION) || \ |
275 | defined(CONFIG_DOS_PARTITION) || \ | |
276 | defined(CONFIG_ISO_PARTITION) || \ | |
277 | defined(CONFIG_AMIGA_PARTITION) || \ | |
278 | defined(CONFIG_EFI_PARTITION) | |
279 | ||
affae2bf WD |
280 | static void print_part_header (const char *type, block_dev_desc_t * dev_desc) |
281 | { | |
282 | puts ("\nPartition Map for "); | |
283 | switch (dev_desc->if_type) { | |
726c0f1e DZ |
284 | case IF_TYPE_IDE: |
285 | puts ("IDE"); | |
286 | break; | |
287 | case IF_TYPE_SATA: | |
288 | puts ("SATA"); | |
289 | break; | |
290 | case IF_TYPE_SCSI: | |
291 | puts ("SCSI"); | |
292 | break; | |
293 | case IF_TYPE_ATAPI: | |
294 | puts ("ATAPI"); | |
295 | break; | |
296 | case IF_TYPE_USB: | |
297 | puts ("USB"); | |
298 | break; | |
299 | case IF_TYPE_DOC: | |
300 | puts ("DOC"); | |
301 | break; | |
8f3b9642 LW |
302 | case IF_TYPE_MMC: |
303 | puts ("MMC"); | |
304 | break; | |
726c0f1e DZ |
305 | default: |
306 | puts ("UNKNOWN"); | |
307 | break; | |
affae2bf WD |
308 | } |
309 | printf (" device %d -- Partition Type: %s\n\n", | |
310 | dev_desc->dev, type); | |
311 | } | |
312 | ||
0c9c8fb5 GB |
313 | #endif /* any CONFIG_..._PARTITION */ |
314 | ||
affae2bf WD |
315 | void print_part (block_dev_desc_t * dev_desc) |
316 | { | |
317 | ||
318 | switch (dev_desc->part_type) { | |
319 | #ifdef CONFIG_MAC_PARTITION | |
320 | case PART_TYPE_MAC: | |
321 | PRINTF ("## Testing for valid MAC partition ##\n"); | |
322 | print_part_header ("MAC", dev_desc); | |
323 | print_part_mac (dev_desc); | |
324 | return; | |
325 | #endif | |
326 | #ifdef CONFIG_DOS_PARTITION | |
327 | case PART_TYPE_DOS: | |
328 | PRINTF ("## Testing for valid DOS partition ##\n"); | |
329 | print_part_header ("DOS", dev_desc); | |
330 | print_part_dos (dev_desc); | |
331 | return; | |
332 | #endif | |
333 | ||
334 | #ifdef CONFIG_ISO_PARTITION | |
335 | case PART_TYPE_ISO: | |
336 | PRINTF ("## Testing for valid ISO Boot partition ##\n"); | |
337 | print_part_header ("ISO", dev_desc); | |
338 | print_part_iso (dev_desc); | |
339 | return; | |
340 | #endif | |
c7de829c WD |
341 | |
342 | #ifdef CONFIG_AMIGA_PARTITION | |
343 | case PART_TYPE_AMIGA: | |
344 | PRINTF ("## Testing for a valid Amiga partition ##\n"); | |
345 | print_part_header ("AMIGA", dev_desc); | |
346 | print_part_amiga (dev_desc); | |
347 | return; | |
348 | #endif | |
07f3d789 | 349 | |
350 | #ifdef CONFIG_EFI_PARTITION | |
351 | case PART_TYPE_EFI: | |
352 | PRINTF ("## Testing for valid EFI partition ##\n"); | |
353 | print_part_header ("EFI", dev_desc); | |
354 | print_part_efi (dev_desc); | |
355 | return; | |
356 | #endif | |
affae2bf WD |
357 | } |
358 | puts ("## Unknown partition table\n"); | |
359 | } | |
360 | ||
0c9c8fb5 | 361 | #endif /* HAVE_BLOCK_DEVICE */ |
2f501646 SW |
362 | |
363 | int get_partition_info(block_dev_desc_t *dev_desc, int part | |
364 | , disk_partition_t *info) | |
365 | { | |
0c9c8fb5 | 366 | #ifdef HAVE_BLOCK_DEVICE |
2f501646 | 367 | |
894bfbbf SW |
368 | #ifdef CONFIG_PARTITION_UUIDS |
369 | /* The common case is no UUID support */ | |
370 | info->uuid[0] = 0; | |
371 | #endif | |
372 | ||
2f501646 SW |
373 | switch (dev_desc->part_type) { |
374 | #ifdef CONFIG_MAC_PARTITION | |
375 | case PART_TYPE_MAC: | |
376 | if (get_partition_info_mac(dev_desc, part, info) == 0) { | |
377 | PRINTF("## Valid MAC partition found ##\n"); | |
378 | return 0; | |
379 | } | |
380 | break; | |
381 | #endif | |
382 | ||
383 | #ifdef CONFIG_DOS_PARTITION | |
384 | case PART_TYPE_DOS: | |
385 | if (get_partition_info_dos(dev_desc, part, info) == 0) { | |
386 | PRINTF("## Valid DOS partition found ##\n"); | |
387 | return 0; | |
388 | } | |
389 | break; | |
390 | #endif | |
391 | ||
392 | #ifdef CONFIG_ISO_PARTITION | |
393 | case PART_TYPE_ISO: | |
394 | if (get_partition_info_iso(dev_desc, part, info) == 0) { | |
395 | PRINTF("## Valid ISO boot partition found ##\n"); | |
396 | return 0; | |
397 | } | |
398 | break; | |
399 | #endif | |
400 | ||
401 | #ifdef CONFIG_AMIGA_PARTITION | |
402 | case PART_TYPE_AMIGA: | |
403 | if (get_partition_info_amiga(dev_desc, part, info) == 0) { | |
404 | PRINTF("## Valid Amiga partition found ##\n"); | |
405 | return 0; | |
406 | } | |
407 | break; | |
408 | #endif | |
409 | ||
410 | #ifdef CONFIG_EFI_PARTITION | |
411 | case PART_TYPE_EFI: | |
412 | if (get_partition_info_efi(dev_desc, part, info) == 0) { | |
413 | PRINTF("## Valid EFI partition found ##\n"); | |
414 | return 0; | |
415 | } | |
416 | break; | |
417 | #endif | |
418 | default: | |
419 | break; | |
420 | } | |
0c9c8fb5 | 421 | #endif /* HAVE_BLOCK_DEVICE */ |
2f501646 SW |
422 | |
423 | return -1; | |
424 | } | |
99d2c205 | 425 | |
2023e608 SW |
426 | int get_device(const char *ifname, const char *dev_str, |
427 | block_dev_desc_t **dev_desc) | |
428 | { | |
429 | char *ep; | |
430 | int dev; | |
431 | ||
432 | dev = simple_strtoul(dev_str, &ep, 16); | |
433 | if (*ep) { | |
434 | printf("** Bad device specification %s %s **\n", | |
435 | ifname, dev_str); | |
436 | return -1; | |
437 | } | |
438 | ||
439 | *dev_desc = get_dev(ifname, dev); | |
440 | if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) { | |
441 | printf("** Bad device %s %s **\n", ifname, dev_str); | |
442 | return -1; | |
443 | } | |
444 | ||
445 | return dev; | |
446 | } | |
447 | ||
10a37fd7 SW |
448 | #define PART_UNSPECIFIED -2 |
449 | #define PART_AUTO -1 | |
450 | #define MAX_SEARCH_PARTITIONS 16 | |
451 | int get_device_and_partition(const char *ifname, const char *dev_part_str, | |
99d2c205 | 452 | block_dev_desc_t **dev_desc, |
10a37fd7 | 453 | disk_partition_t *info, int allow_whole_dev) |
99d2c205 | 454 | { |
10a37fd7 SW |
455 | int ret = -1; |
456 | const char *part_str; | |
457 | char *dup_str = NULL; | |
458 | const char *dev_str; | |
99d2c205 | 459 | int dev; |
10a37fd7 SW |
460 | char *ep; |
461 | int p; | |
462 | int part; | |
463 | disk_partition_t tmpinfo; | |
464 | ||
92ccc96b SG |
465 | /* |
466 | * For now, we have a special case for sandbox, since there is no | |
467 | * real block device support. | |
468 | */ | |
469 | if (0 == strcmp(ifname, "host")) { | |
470 | *dev_desc = NULL; | |
471 | info->start = info->size = info->blksz = 0; | |
472 | info->bootable = 0; | |
473 | strcpy((char *)info->type, BOOT_PART_TYPE); | |
474 | strcpy((char *)info->name, "Sandbox host"); | |
475 | #ifdef CONFIG_PARTITION_UUIDS | |
476 | info->uuid[0] = 0; | |
477 | #endif | |
478 | ||
479 | return 0; | |
480 | } | |
481 | ||
10a37fd7 | 482 | /* If no dev_part_str, use bootdevice environment variable */ |
a10973e7 SW |
483 | if (!dev_part_str || !strlen(dev_part_str) || |
484 | !strcmp(dev_part_str, "-")) | |
10a37fd7 SW |
485 | dev_part_str = getenv("bootdevice"); |
486 | ||
487 | /* If still no dev_part_str, it's an error */ | |
488 | if (!dev_part_str) { | |
489 | printf("** No device specified **\n"); | |
490 | goto cleanup; | |
491 | } | |
492 | ||
493 | /* Separate device and partition ID specification */ | |
494 | part_str = strchr(dev_part_str, ':'); | |
495 | if (part_str) { | |
496 | dup_str = strdup(dev_part_str); | |
497 | dup_str[part_str - dev_part_str] = 0; | |
498 | dev_str = dup_str; | |
499 | part_str++; | |
500 | } else { | |
501 | dev_str = dev_part_str; | |
99d2c205 RH |
502 | } |
503 | ||
10a37fd7 SW |
504 | /* Look up the device */ |
505 | dev = get_device(ifname, dev_str, dev_desc); | |
506 | if (dev < 0) | |
507 | goto cleanup; | |
508 | ||
509 | /* Convert partition ID string to number */ | |
510 | if (!part_str || !*part_str) { | |
511 | part = PART_UNSPECIFIED; | |
512 | } else if (!strcmp(part_str, "auto")) { | |
513 | part = PART_AUTO; | |
514 | } else { | |
515 | /* Something specified -> use exactly that */ | |
516 | part = (int)simple_strtoul(part_str, &ep, 16); | |
517 | /* | |
518 | * Less than whole string converted, | |
519 | * or request for whole device, but caller requires partition. | |
520 | */ | |
521 | if (*ep || (part == 0 && !allow_whole_dev)) { | |
522 | printf("** Bad partition specification %s %s **\n", | |
523 | ifname, dev_part_str); | |
524 | goto cleanup; | |
525 | } | |
526 | } | |
527 | ||
528 | /* | |
529 | * No partition table on device, | |
530 | * or user requested partition 0 (entire device). | |
531 | */ | |
532 | if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) || | |
533 | (part == 0)) { | |
534 | if (!(*dev_desc)->lba) { | |
535 | printf("** Bad device size - %s %s **\n", ifname, | |
536 | dev_str); | |
537 | goto cleanup; | |
538 | } | |
99d2c205 | 539 | |
10a37fd7 SW |
540 | /* |
541 | * If user specified a partition ID other than 0, | |
542 | * or the calling command only accepts partitions, | |
543 | * it's an error. | |
544 | */ | |
545 | if ((part > 0) || (!allow_whole_dev)) { | |
546 | printf("** No partition table - %s %s **\n", ifname, | |
547 | dev_str); | |
548 | goto cleanup; | |
99d2c205 | 549 | } |
10a37fd7 | 550 | |
50ffc3b6 LY |
551 | (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz); |
552 | ||
99d2c205 | 553 | info->start = 0; |
10a37fd7 SW |
554 | info->size = (*dev_desc)->lba; |
555 | info->blksz = (*dev_desc)->blksz; | |
556 | info->bootable = 0; | |
6ab6a650 SW |
557 | strcpy((char *)info->type, BOOT_PART_TYPE); |
558 | strcpy((char *)info->name, "Whole Disk"); | |
10a37fd7 SW |
559 | #ifdef CONFIG_PARTITION_UUIDS |
560 | info->uuid[0] = 0; | |
561 | #endif | |
99d2c205 | 562 | |
10a37fd7 SW |
563 | ret = 0; |
564 | goto cleanup; | |
99d2c205 RH |
565 | } |
566 | ||
10a37fd7 SW |
567 | /* |
568 | * Now there's known to be a partition table, | |
569 | * not specifying a partition means to pick partition 1. | |
570 | */ | |
571 | if (part == PART_UNSPECIFIED) | |
572 | part = 1; | |
573 | ||
574 | /* | |
575 | * If user didn't specify a partition number, or did specify something | |
576 | * other than "auto", use that partition number directly. | |
577 | */ | |
578 | if (part != PART_AUTO) { | |
579 | ret = get_partition_info(*dev_desc, part, info); | |
580 | if (ret) { | |
581 | printf("** Invalid partition %d **\n", part); | |
582 | goto cleanup; | |
583 | } | |
584 | } else { | |
585 | /* | |
586 | * Find the first bootable partition. | |
587 | * If none are bootable, fall back to the first valid partition. | |
588 | */ | |
589 | part = 0; | |
590 | for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) { | |
591 | ret = get_partition_info(*dev_desc, p, info); | |
592 | if (ret) | |
593 | continue; | |
594 | ||
595 | /* | |
596 | * First valid partition, or new better partition? | |
597 | * If so, save partition ID. | |
598 | */ | |
599 | if (!part || info->bootable) | |
600 | part = p; | |
601 | ||
602 | /* Best possible partition? Stop searching. */ | |
603 | if (info->bootable) | |
604 | break; | |
605 | ||
606 | /* | |
607 | * We now need to search further for best possible. | |
608 | * If we what we just queried was the best so far, | |
609 | * save the info since we over-write it next loop. | |
610 | */ | |
611 | if (part == p) | |
612 | tmpinfo = *info; | |
613 | } | |
614 | /* If we found any acceptable partition */ | |
615 | if (part) { | |
616 | /* | |
617 | * If we searched all possible partition IDs, | |
618 | * return the first valid partition we found. | |
619 | */ | |
620 | if (p == MAX_SEARCH_PARTITIONS + 1) | |
621 | *info = tmpinfo; | |
10a37fd7 SW |
622 | } else { |
623 | printf("** No valid partitions found **\n"); | |
71bba424 | 624 | ret = -1; |
10a37fd7 SW |
625 | goto cleanup; |
626 | } | |
99d2c205 RH |
627 | } |
628 | if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) { | |
629 | printf("** Invalid partition type \"%.32s\"" | |
630 | " (expect \"" BOOT_PART_TYPE "\")\n", | |
631 | info->type); | |
10a37fd7 SW |
632 | ret = -1; |
633 | goto cleanup; | |
99d2c205 RH |
634 | } |
635 | ||
50ffc3b6 LY |
636 | (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz); |
637 | ||
10a37fd7 SW |
638 | ret = part; |
639 | goto cleanup; | |
99d2c205 | 640 | |
10a37fd7 SW |
641 | cleanup: |
642 | free(dup_str); | |
643 | return ret; | |
99d2c205 | 644 | } |