]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
affae2bf WD |
2 | /* |
3 | * (C) Copyright 2001 | |
4 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
affae2bf WD |
5 | */ |
6 | ||
7 | #include <common.h> | |
e6f6f9e6 | 8 | #include <blk.h> |
affae2bf | 9 | #include <command.h> |
7b51b576 | 10 | #include <env.h> |
96e5b03c | 11 | #include <errno.h> |
affae2bf | 12 | #include <ide.h> |
f7ae49fc | 13 | #include <log.h> |
10a37fd7 | 14 | #include <malloc.h> |
735dd97b | 15 | #include <part.h> |
251cee0d | 16 | #include <ubifs_uboot.h> |
affae2bf WD |
17 | |
18 | #undef PART_DEBUG | |
19 | ||
20 | #ifdef PART_DEBUG | |
21 | #define PRINTF(fmt,args...) printf (fmt ,##args) | |
22 | #else | |
23 | #define PRINTF(fmt,args...) | |
24 | #endif | |
25 | ||
30789095 SP |
26 | /* Check all partition types */ |
27 | #define PART_TYPE_ALL -1 | |
28 | ||
387f8be5 JW |
29 | static struct part_driver *part_driver_get_type(int part_type) |
30 | { | |
31 | struct part_driver *drv = | |
32 | ll_entry_start(struct part_driver, part_driver); | |
33 | const int n_ents = ll_entry_count(struct part_driver, part_driver); | |
34 | struct part_driver *entry; | |
35 | ||
36 | for (entry = drv; entry != drv + n_ents; entry++) { | |
37 | if (part_type == entry->part_type) | |
38 | return entry; | |
39 | } | |
40 | ||
41 | /* Not found */ | |
42 | return NULL; | |
43 | } | |
44 | ||
d4729269 | 45 | static struct part_driver *part_driver_lookup_type(struct blk_desc *dev_desc) |
96e5b03c SG |
46 | { |
47 | struct part_driver *drv = | |
48 | ll_entry_start(struct part_driver, part_driver); | |
49 | const int n_ents = ll_entry_count(struct part_driver, part_driver); | |
50 | struct part_driver *entry; | |
51 | ||
d4729269 KY |
52 | if (dev_desc->part_type == PART_TYPE_UNKNOWN) { |
53 | for (entry = drv; entry != drv + n_ents; entry++) { | |
54 | int ret; | |
55 | ||
56 | ret = entry->test(dev_desc); | |
57 | if (!ret) { | |
58 | dev_desc->part_type = entry->part_type; | |
59 | return entry; | |
60 | } | |
61 | } | |
62 | } else { | |
387f8be5 | 63 | return part_driver_get_type(dev_desc->part_type); |
96e5b03c SG |
64 | } |
65 | ||
66 | /* Not found */ | |
67 | return NULL; | |
68 | } | |
69 | ||
125194e6 SG |
70 | int part_get_type_by_name(const char *name) |
71 | { | |
72 | struct part_driver *drv = | |
73 | ll_entry_start(struct part_driver, part_driver); | |
74 | const int n_ents = ll_entry_count(struct part_driver, part_driver); | |
75 | struct part_driver *entry; | |
76 | ||
77 | for (entry = drv; entry != drv + n_ents; entry++) { | |
78 | if (!strcasecmp(name, entry->name)) | |
79 | return entry->part_type; | |
80 | } | |
81 | ||
82 | /* Not found */ | |
83 | return PART_TYPE_UNKNOWN; | |
84 | } | |
85 | ||
4101f687 | 86 | static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart) |
735dd97b | 87 | { |
6dd9faf8 SG |
88 | struct blk_desc *dev_desc; |
89 | int ret; | |
735dd97b | 90 | |
a51eb8de SG |
91 | if (!blk_enabled()) |
92 | return NULL; | |
8149b150 | 93 | dev_desc = blk_get_devnum_by_uclass_idname(ifname, dev); |
6dd9faf8 SG |
94 | if (!dev_desc) { |
95 | debug("%s: No device for iface '%s', dev %d\n", __func__, | |
96 | ifname, dev); | |
7e71dc68 | 97 | return NULL; |
735dd97b | 98 | } |
6dd9faf8 SG |
99 | ret = blk_dselect_hwpart(dev_desc, hwpart); |
100 | if (ret) { | |
101 | debug("%s: Failed to select h/w partition: err-%d\n", __func__, | |
102 | ret); | |
103 | return NULL; | |
104 | } | |
105 | ||
106 | return dev_desc; | |
735dd97b | 107 | } |
336b6f90 | 108 | |
db1d9e78 | 109 | struct blk_desc *blk_get_dev(const char *ifname, int dev) |
336b6f90 | 110 | { |
a51eb8de SG |
111 | if (!blk_enabled()) |
112 | return NULL; | |
336b6f90 | 113 | |
a51eb8de | 114 | return get_dev_hwpart(ifname, dev, 0); |
735dd97b | 115 | } |
affae2bf WD |
116 | |
117 | /* ------------------------------------------------------------------------- */ | |
118 | /* | |
119 | * reports device info to the user | |
120 | */ | |
69a2a4d9 | 121 | |
42dfe7a1 | 122 | #ifdef CONFIG_LBA48 |
69a2a4d9 | 123 | typedef uint64_t lba512_t; |
c40b2956 | 124 | #else |
69a2a4d9 | 125 | typedef lbaint_t lba512_t; |
c40b2956 | 126 | #endif |
affae2bf | 127 | |
69a2a4d9 | 128 | /* |
a9d1c0e2 HS |
129 | * Overflowless variant of (block_count * mul_by / 2**right_shift) |
130 | * when 2**right_shift > mul_by | |
69a2a4d9 | 131 | */ |
a9d1c0e2 HS |
132 | static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by, |
133 | int right_shift) | |
69a2a4d9 ST |
134 | { |
135 | lba512_t bc_quot, bc_rem; | |
136 | ||
137 | /* x * m / d == x / d * m + (x % d) * m / d */ | |
a9d1c0e2 HS |
138 | bc_quot = block_count >> right_shift; |
139 | bc_rem = block_count - (bc_quot << right_shift); | |
140 | return bc_quot * mul_by + ((bc_rem * mul_by) >> right_shift); | |
69a2a4d9 ST |
141 | } |
142 | ||
ef4b66bc | 143 | void dev_print(struct blk_desc *dev_desc) |
69a2a4d9 ST |
144 | { |
145 | lba512_t lba512; /* number of blocks if 512bytes block size */ | |
146 | ||
af75a45d WD |
147 | if (dev_desc->type == DEV_TYPE_UNKNOWN) { |
148 | puts ("not available\n"); | |
149 | return; | |
150 | } | |
151 | ||
8149b150 | 152 | switch (dev_desc->uclass_id) { |
e33a5c6b | 153 | case UCLASS_SCSI: |
574b3195 DZ |
154 | printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n", |
155 | dev_desc->target,dev_desc->lun, | |
affae2bf | 156 | dev_desc->vendor, |
574b3195 DZ |
157 | dev_desc->product, |
158 | dev_desc->revision); | |
159 | break; | |
e33a5c6b SG |
160 | case UCLASS_IDE: |
161 | case UCLASS_AHCI: | |
c7057b52 DL |
162 | printf ("Model: %s Firm: %s Ser#: %s\n", |
163 | dev_desc->vendor, | |
164 | dev_desc->revision, | |
165 | dev_desc->product); | |
574b3195 | 166 | break; |
e33a5c6b SG |
167 | case UCLASS_MMC: |
168 | case UCLASS_USB: | |
169 | case UCLASS_NVME: | |
170 | case UCLASS_PVBLOCK: | |
95201811 | 171 | case UCLASS_HOST: |
bb56da11 | 172 | case UCLASS_BLKMAP: |
47bebe34 NCL |
173 | printf ("Vendor: %s Rev: %s Prod: %s\n", |
174 | dev_desc->vendor, | |
175 | dev_desc->revision, | |
176 | dev_desc->product); | |
177 | break; | |
e33a5c6b | 178 | case UCLASS_VIRTIO: |
4ad54ec4 TT |
179 | printf("%s VirtIO Block Device\n", dev_desc->vendor); |
180 | break; | |
ef4b66bc SG |
181 | case UCLASS_EFI_MEDIA: |
182 | printf("EFI media Block Device %d\n", dev_desc->devnum); | |
183 | break; | |
e33a5c6b | 184 | case UCLASS_INVALID: |
6e24a1eb RB |
185 | puts("device type unknown\n"); |
186 | return; | |
574b3195 | 187 | default: |
8149b150 | 188 | printf("Unhandled device type: %i\n", dev_desc->uclass_id); |
574b3195 | 189 | return; |
affae2bf WD |
190 | } |
191 | puts (" Type: "); | |
192 | if (dev_desc->removable) | |
193 | puts ("Removable "); | |
194 | switch (dev_desc->type & 0x1F) { | |
726c0f1e DZ |
195 | case DEV_TYPE_HARDDISK: |
196 | puts ("Hard Disk"); | |
197 | break; | |
198 | case DEV_TYPE_CDROM: | |
199 | puts ("CD ROM"); | |
200 | break; | |
201 | case DEV_TYPE_OPDISK: | |
202 | puts ("Optical Device"); | |
203 | break; | |
204 | case DEV_TYPE_TAPE: | |
205 | puts ("Tape"); | |
206 | break; | |
207 | default: | |
208 | printf ("# %02X #", dev_desc->type & 0x1F); | |
209 | break; | |
affae2bf WD |
210 | } |
211 | puts ("\n"); | |
33699df1 | 212 | if (dev_desc->lba > 0L && dev_desc->blksz > 0L) { |
affae2bf | 213 | ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem; |
c40b2956 | 214 | lbaint_t lba; |
6e592385 WD |
215 | |
216 | lba = dev_desc->lba; | |
affae2bf | 217 | |
c40b2956 | 218 | lba512 = (lba * (dev_desc->blksz/512)); |
affae2bf | 219 | /* round to 1 digit */ |
214b3f31 | 220 | /* 2048 = (1024 * 1024) / 512 MB */ |
17416eaf | 221 | mb = lba512_muldiv(lba512, 10, 11); |
69a2a4d9 | 222 | |
affae2bf WD |
223 | mb_quot = mb / 10; |
224 | mb_rem = mb - (10 * mb_quot); | |
225 | ||
226 | gb = mb / 1024; | |
227 | gb_quot = gb / 10; | |
228 | gb_rem = gb - (10 * gb_quot); | |
42dfe7a1 | 229 | #ifdef CONFIG_LBA48 |
6e592385 | 230 | if (dev_desc->lba48) |
c40b2956 WD |
231 | printf (" Supports 48-bit addressing\n"); |
232 | #endif | |
4b142feb | 233 | #if defined(CONFIG_SYS_64BIT_LBA) |
139f7b1d | 234 | printf (" Capacity: %lu.%lu MB = %lu.%lu GB (%llu x %lu)\n", |
c40b2956 WD |
235 | mb_quot, mb_rem, |
236 | gb_quot, gb_rem, | |
237 | lba, | |
238 | dev_desc->blksz); | |
239 | #else | |
139f7b1d | 240 | printf (" Capacity: %lu.%lu MB = %lu.%lu GB (%lu x %lu)\n", |
affae2bf WD |
241 | mb_quot, mb_rem, |
242 | gb_quot, gb_rem, | |
c40b2956 | 243 | (ulong)lba, |
affae2bf | 244 | dev_desc->blksz); |
c40b2956 | 245 | #endif |
affae2bf WD |
246 | } else { |
247 | puts (" Capacity: not available\n"); | |
248 | } | |
249 | } | |
affae2bf | 250 | |
3e8bd469 | 251 | void part_init(struct blk_desc *dev_desc) |
affae2bf | 252 | { |
96e5b03c SG |
253 | struct part_driver *drv = |
254 | ll_entry_start(struct part_driver, part_driver); | |
255 | const int n_ents = ll_entry_count(struct part_driver, part_driver); | |
256 | struct part_driver *entry; | |
affae2bf | 257 | |
8149b150 | 258 | blkcache_invalidate(dev_desc->uclass_id, dev_desc->devnum); |
e40cf34a | 259 | |
99d2c205 | 260 | dev_desc->part_type = PART_TYPE_UNKNOWN; |
96e5b03c SG |
261 | for (entry = drv; entry != drv + n_ents; entry++) { |
262 | int ret; | |
263 | ||
264 | ret = entry->test(dev_desc); | |
265 | debug("%s: try '%s': ret=%d\n", __func__, entry->name, ret); | |
266 | if (!ret) { | |
267 | dev_desc->part_type = entry->part_type; | |
268 | break; | |
269 | } | |
270 | } | |
affae2bf WD |
271 | } |
272 | ||
96e5b03c SG |
273 | static void print_part_header(const char *type, struct blk_desc *dev_desc) |
274 | { | |
f18fa31c | 275 | #if CONFIG_IS_ENABLED(MAC_PARTITION) || \ |
b0cf7339 | 276 | CONFIG_IS_ENABLED(DOS_PARTITION) || \ |
1acc0087 | 277 | CONFIG_IS_ENABLED(ISO_PARTITION) || \ |
863c5b6c | 278 | CONFIG_IS_ENABLED(AMIGA_PARTITION) || \ |
bd42a942 | 279 | CONFIG_IS_ENABLED(EFI_PARTITION) |
affae2bf | 280 | puts ("\nPartition Map for "); |
8149b150 | 281 | switch (dev_desc->uclass_id) { |
e33a5c6b | 282 | case UCLASS_IDE: |
726c0f1e DZ |
283 | puts ("IDE"); |
284 | break; | |
e33a5c6b | 285 | case UCLASS_AHCI: |
726c0f1e DZ |
286 | puts ("SATA"); |
287 | break; | |
e33a5c6b | 288 | case UCLASS_SCSI: |
726c0f1e DZ |
289 | puts ("SCSI"); |
290 | break; | |
e33a5c6b | 291 | case UCLASS_USB: |
726c0f1e DZ |
292 | puts ("USB"); |
293 | break; | |
e33a5c6b | 294 | case UCLASS_MMC: |
8f3b9642 LW |
295 | puts ("MMC"); |
296 | break; | |
95201811 | 297 | case UCLASS_HOST: |
ffab6945 ZZ |
298 | puts ("HOST"); |
299 | break; | |
e33a5c6b | 300 | case UCLASS_NVME: |
ffab6945 | 301 | puts ("NVMe"); |
f4d8de48 | 302 | break; |
e33a5c6b | 303 | case UCLASS_PVBLOCK: |
722bc5b5 AL |
304 | puts("PV BLOCK"); |
305 | break; | |
e33a5c6b | 306 | case UCLASS_VIRTIO: |
4ad54ec4 TT |
307 | puts("VirtIO"); |
308 | break; | |
e33a5c6b | 309 | case UCLASS_EFI_MEDIA: |
42b7f421 SG |
310 | puts("EFI"); |
311 | break; | |
726c0f1e | 312 | default: |
42b7f421 | 313 | puts("UNKNOWN"); |
726c0f1e | 314 | break; |
affae2bf WD |
315 | } |
316 | printf (" device %d -- Partition Type: %s\n\n", | |
bcce53d0 | 317 | dev_desc->devnum, type); |
0c9c8fb5 | 318 | #endif /* any CONFIG_..._PARTITION */ |
96e5b03c | 319 | } |
0c9c8fb5 | 320 | |
3e8bd469 | 321 | void part_print(struct blk_desc *dev_desc) |
affae2bf | 322 | { |
96e5b03c | 323 | struct part_driver *drv; |
affae2bf | 324 | |
d4729269 | 325 | drv = part_driver_lookup_type(dev_desc); |
96e5b03c SG |
326 | if (!drv) { |
327 | printf("## Unknown partition table type %x\n", | |
328 | dev_desc->part_type); | |
affae2bf | 329 | return; |
affae2bf | 330 | } |
96e5b03c SG |
331 | |
332 | PRINTF("## Testing for valid %s partition ##\n", drv->name); | |
333 | print_part_header(drv->name, dev_desc); | |
334 | if (drv->print) | |
335 | drv->print(dev_desc); | |
affae2bf WD |
336 | } |
337 | ||
387f8be5 JW |
338 | int part_get_info_by_type(struct blk_desc *dev_desc, int part, int part_type, |
339 | struct disk_partition *info) | |
2f501646 | 340 | { |
96e5b03c | 341 | struct part_driver *drv; |
2f501646 | 342 | |
a51eb8de | 343 | if (blk_enabled()) { |
b331cd62 | 344 | #if CONFIG_IS_ENABLED(PARTITION_UUIDS) |
a51eb8de SG |
345 | /* The common case is no UUID support */ |
346 | info->uuid[0] = 0; | |
894bfbbf | 347 | #endif |
7561b258 | 348 | #ifdef CONFIG_PARTITION_TYPE_GUID |
a51eb8de | 349 | info->type_guid[0] = 0; |
7561b258 | 350 | #endif |
894bfbbf | 351 | |
387f8be5 JW |
352 | if (part_type == PART_TYPE_UNKNOWN) { |
353 | drv = part_driver_lookup_type(dev_desc); | |
354 | } else { | |
355 | drv = part_driver_get_type(part_type); | |
356 | } | |
357 | ||
a51eb8de SG |
358 | if (!drv) { |
359 | debug("## Unknown partition table type %x\n", | |
360 | dev_desc->part_type); | |
361 | return -EPROTONOSUPPORT; | |
362 | } | |
363 | if (!drv->get_info) { | |
364 | PRINTF("## Driver %s does not have the get_info() method\n", | |
365 | drv->name); | |
366 | return -ENOSYS; | |
367 | } | |
368 | if (drv->get_info(dev_desc, part, info) == 0) { | |
369 | PRINTF("## Valid %s partition found ##\n", drv->name); | |
370 | return 0; | |
371 | } | |
2f501646 | 372 | } |
2f501646 | 373 | |
59715754 | 374 | return -ENOENT; |
2f501646 | 375 | } |
99d2c205 | 376 | |
387f8be5 JW |
377 | int part_get_info(struct blk_desc *dev_desc, int part, |
378 | struct disk_partition *info) | |
379 | { | |
380 | return part_get_info_by_type(dev_desc, part, PART_TYPE_UNKNOWN, info); | |
381 | } | |
382 | ||
0528979f SG |
383 | int part_get_info_whole_disk(struct blk_desc *dev_desc, |
384 | struct disk_partition *info) | |
4bbcc965 RC |
385 | { |
386 | info->start = 0; | |
387 | info->size = dev_desc->lba; | |
388 | info->blksz = dev_desc->blksz; | |
389 | info->bootable = 0; | |
390 | strcpy((char *)info->type, BOOT_PART_TYPE); | |
391 | strcpy((char *)info->name, "Whole Disk"); | |
392 | #if CONFIG_IS_ENABLED(PARTITION_UUIDS) | |
393 | info->uuid[0] = 0; | |
394 | #endif | |
395 | #ifdef CONFIG_PARTITION_TYPE_GUID | |
396 | info->type_guid[0] = 0; | |
397 | #endif | |
398 | ||
399 | return 0; | |
400 | } | |
401 | ||
ebac37cf SG |
402 | int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str, |
403 | struct blk_desc **dev_desc) | |
2023e608 SW |
404 | { |
405 | char *ep; | |
336b6f90 SW |
406 | char *dup_str = NULL; |
407 | const char *dev_str, *hwpart_str; | |
408 | int dev, hwpart; | |
409 | ||
410 | hwpart_str = strchr(dev_hwpart_str, '.'); | |
411 | if (hwpart_str) { | |
412 | dup_str = strdup(dev_hwpart_str); | |
413 | dup_str[hwpart_str - dev_hwpart_str] = 0; | |
414 | dev_str = dup_str; | |
415 | hwpart_str++; | |
416 | } else { | |
417 | dev_str = dev_hwpart_str; | |
ecdd57e2 | 418 | hwpart = 0; |
336b6f90 | 419 | } |
2023e608 | 420 | |
7e5f460e | 421 | dev = hextoul(dev_str, &ep); |
2023e608 SW |
422 | if (*ep) { |
423 | printf("** Bad device specification %s %s **\n", | |
424 | ifname, dev_str); | |
1598dfcb | 425 | dev = -EINVAL; |
336b6f90 SW |
426 | goto cleanup; |
427 | } | |
428 | ||
429 | if (hwpart_str) { | |
7e5f460e | 430 | hwpart = hextoul(hwpart_str, &ep); |
336b6f90 SW |
431 | if (*ep) { |
432 | printf("** Bad HW partition specification %s %s **\n", | |
433 | ifname, hwpart_str); | |
1598dfcb | 434 | dev = -EINVAL; |
336b6f90 SW |
435 | goto cleanup; |
436 | } | |
2023e608 SW |
437 | } |
438 | ||
336b6f90 | 439 | *dev_desc = get_dev_hwpart(ifname, dev, hwpart); |
2023e608 | 440 | if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) { |
8f690848 | 441 | debug("** Bad device %s %s **\n", ifname, dev_hwpart_str); |
59715754 | 442 | dev = -ENODEV; |
336b6f90 | 443 | goto cleanup; |
2023e608 SW |
444 | } |
445 | ||
a51eb8de SG |
446 | if (blk_enabled()) { |
447 | /* | |
448 | * Updates the partition table for the specified hw partition. | |
449 | * Always should be done, otherwise hw partition 0 will return | |
450 | * stale data after displaying a non-zero hw partition. | |
451 | */ | |
8149b150 | 452 | if ((*dev_desc)->uclass_id == UCLASS_MMC) |
a51eb8de SG |
453 | part_init(*dev_desc); |
454 | } | |
99e7fc8a | 455 | |
336b6f90 SW |
456 | cleanup: |
457 | free(dup_str); | |
2023e608 SW |
458 | return dev; |
459 | } | |
460 | ||
10a37fd7 SW |
461 | #define PART_UNSPECIFIED -2 |
462 | #define PART_AUTO -1 | |
e35929e4 | 463 | int blk_get_device_part_str(const char *ifname, const char *dev_part_str, |
4101f687 | 464 | struct blk_desc **dev_desc, |
0528979f | 465 | struct disk_partition *info, int allow_whole_dev) |
99d2c205 | 466 | { |
59715754 | 467 | int ret; |
10a37fd7 SW |
468 | const char *part_str; |
469 | char *dup_str = NULL; | |
470 | const char *dev_str; | |
99d2c205 | 471 | int dev; |
10a37fd7 SW |
472 | char *ep; |
473 | int p; | |
474 | int part; | |
0528979f | 475 | struct disk_partition tmpinfo; |
10a37fd7 | 476 | |
be2e42fa HS |
477 | *dev_desc = NULL; |
478 | memset(info, 0, sizeof(*info)); | |
479 | ||
f676b451 | 480 | #if IS_ENABLED(CONFIG_SANDBOX) || IS_ENABLED(CONFIG_SEMIHOSTING) |
4d907025 | 481 | /* |
3f9eb6e1 | 482 | * Special-case a pseudo block device "hostfs", to allow access to the |
4d907025 SW |
483 | * host's own filesystem. |
484 | */ | |
be2e42fa | 485 | if (!strcmp(ifname, "hostfs")) { |
4d907025 | 486 | strcpy((char *)info->type, BOOT_PART_TYPE); |
f676b451 | 487 | strcpy((char *)info->name, "Host filesystem"); |
4d907025 SW |
488 | |
489 | return 0; | |
490 | } | |
afc1744e | 491 | #endif |
4d907025 | 492 | |
2f03a639 | 493 | #if IS_ENABLED(CONFIG_CMD_UBIFS) && !IS_ENABLED(CONFIG_SPL_BUILD) |
251cee0d | 494 | /* |
3174cafd | 495 | * Special-case ubi, ubi goes through a mtd, rather than through |
251cee0d HG |
496 | * a regular block device. |
497 | */ | |
be2e42fa | 498 | if (!strcmp(ifname, "ubi")) { |
251cee0d HG |
499 | if (!ubifs_is_mounted()) { |
500 | printf("UBIFS not mounted, use ubifsmount to mount volume first!\n"); | |
59715754 | 501 | return -EINVAL; |
251cee0d HG |
502 | } |
503 | ||
251cee0d HG |
504 | strcpy((char *)info->type, BOOT_PART_TYPE); |
505 | strcpy((char *)info->name, "UBI"); | |
251cee0d HG |
506 | return 0; |
507 | } | |
508 | #endif | |
509 | ||
10a37fd7 | 510 | /* If no dev_part_str, use bootdevice environment variable */ |
350635fe HS |
511 | if (CONFIG_IS_ENABLED(ENV_SUPPORT)) { |
512 | if (!dev_part_str || !strlen(dev_part_str) || | |
513 | !strcmp(dev_part_str, "-")) | |
514 | dev_part_str = env_get("bootdevice"); | |
515 | } | |
10a37fd7 SW |
516 | |
517 | /* If still no dev_part_str, it's an error */ | |
518 | if (!dev_part_str) { | |
519 | printf("** No device specified **\n"); | |
59715754 | 520 | ret = -ENODEV; |
10a37fd7 SW |
521 | goto cleanup; |
522 | } | |
523 | ||
524 | /* Separate device and partition ID specification */ | |
525 | part_str = strchr(dev_part_str, ':'); | |
526 | if (part_str) { | |
527 | dup_str = strdup(dev_part_str); | |
528 | dup_str[part_str - dev_part_str] = 0; | |
529 | dev_str = dup_str; | |
530 | part_str++; | |
531 | } else { | |
532 | dev_str = dev_part_str; | |
99d2c205 RH |
533 | } |
534 | ||
10a37fd7 | 535 | /* Look up the device */ |
ebac37cf | 536 | dev = blk_get_device_by_str(ifname, dev_str, dev_desc); |
59715754 | 537 | if (dev < 0) { |
192e7012 OB |
538 | printf("** Bad device specification %s %s **\n", |
539 | ifname, dev_str); | |
59715754 | 540 | ret = dev; |
10a37fd7 | 541 | goto cleanup; |
59715754 | 542 | } |
10a37fd7 SW |
543 | |
544 | /* Convert partition ID string to number */ | |
545 | if (!part_str || !*part_str) { | |
546 | part = PART_UNSPECIFIED; | |
547 | } else if (!strcmp(part_str, "auto")) { | |
548 | part = PART_AUTO; | |
549 | } else { | |
550 | /* Something specified -> use exactly that */ | |
7e5f460e | 551 | part = (int)hextoul(part_str, &ep); |
10a37fd7 SW |
552 | /* |
553 | * Less than whole string converted, | |
554 | * or request for whole device, but caller requires partition. | |
555 | */ | |
556 | if (*ep || (part == 0 && !allow_whole_dev)) { | |
557 | printf("** Bad partition specification %s %s **\n", | |
558 | ifname, dev_part_str); | |
59715754 | 559 | ret = -ENOENT; |
10a37fd7 SW |
560 | goto cleanup; |
561 | } | |
562 | } | |
563 | ||
564 | /* | |
565 | * No partition table on device, | |
566 | * or user requested partition 0 (entire device). | |
567 | */ | |
568 | if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) || | |
569 | (part == 0)) { | |
570 | if (!(*dev_desc)->lba) { | |
571 | printf("** Bad device size - %s %s **\n", ifname, | |
572 | dev_str); | |
59715754 | 573 | ret = -EINVAL; |
10a37fd7 SW |
574 | goto cleanup; |
575 | } | |
99d2c205 | 576 | |
10a37fd7 SW |
577 | /* |
578 | * If user specified a partition ID other than 0, | |
579 | * or the calling command only accepts partitions, | |
580 | * it's an error. | |
581 | */ | |
582 | if ((part > 0) || (!allow_whole_dev)) { | |
583 | printf("** No partition table - %s %s **\n", ifname, | |
584 | dev_str); | |
59715754 | 585 | ret = -EPROTONOSUPPORT; |
10a37fd7 | 586 | goto cleanup; |
99d2c205 | 587 | } |
10a37fd7 | 588 | |
50ffc3b6 LY |
589 | (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz); |
590 | ||
4bbcc965 | 591 | part_get_info_whole_disk(*dev_desc, info); |
99d2c205 | 592 | |
10a37fd7 SW |
593 | ret = 0; |
594 | goto cleanup; | |
99d2c205 RH |
595 | } |
596 | ||
10a37fd7 SW |
597 | /* |
598 | * Now there's known to be a partition table, | |
599 | * not specifying a partition means to pick partition 1. | |
600 | */ | |
601 | if (part == PART_UNSPECIFIED) | |
602 | part = 1; | |
603 | ||
604 | /* | |
605 | * If user didn't specify a partition number, or did specify something | |
606 | * other than "auto", use that partition number directly. | |
607 | */ | |
608 | if (part != PART_AUTO) { | |
3e8bd469 | 609 | ret = part_get_info(*dev_desc, part, info); |
10a37fd7 SW |
610 | if (ret) { |
611 | printf("** Invalid partition %d **\n", part); | |
612 | goto cleanup; | |
613 | } | |
614 | } else { | |
615 | /* | |
616 | * Find the first bootable partition. | |
617 | * If none are bootable, fall back to the first valid partition. | |
618 | */ | |
619 | part = 0; | |
620 | for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) { | |
3e8bd469 | 621 | ret = part_get_info(*dev_desc, p, info); |
10a37fd7 SW |
622 | if (ret) |
623 | continue; | |
624 | ||
625 | /* | |
626 | * First valid partition, or new better partition? | |
627 | * If so, save partition ID. | |
628 | */ | |
629 | if (!part || info->bootable) | |
630 | part = p; | |
631 | ||
632 | /* Best possible partition? Stop searching. */ | |
633 | if (info->bootable) | |
634 | break; | |
635 | ||
636 | /* | |
637 | * We now need to search further for best possible. | |
638 | * If we what we just queried was the best so far, | |
639 | * save the info since we over-write it next loop. | |
640 | */ | |
641 | if (part == p) | |
642 | tmpinfo = *info; | |
643 | } | |
644 | /* If we found any acceptable partition */ | |
645 | if (part) { | |
646 | /* | |
647 | * If we searched all possible partition IDs, | |
648 | * return the first valid partition we found. | |
649 | */ | |
650 | if (p == MAX_SEARCH_PARTITIONS + 1) | |
651 | *info = tmpinfo; | |
10a37fd7 SW |
652 | } else { |
653 | printf("** No valid partitions found **\n"); | |
654 | goto cleanup; | |
655 | } | |
99d2c205 RH |
656 | } |
657 | if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) { | |
658 | printf("** Invalid partition type \"%.32s\"" | |
659 | " (expect \"" BOOT_PART_TYPE "\")\n", | |
660 | info->type); | |
59715754 | 661 | ret = -EINVAL; |
10a37fd7 | 662 | goto cleanup; |
99d2c205 RH |
663 | } |
664 | ||
50ffc3b6 LY |
665 | (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz); |
666 | ||
10a37fd7 SW |
667 | ret = part; |
668 | goto cleanup; | |
99d2c205 | 669 | |
10a37fd7 SW |
670 | cleanup: |
671 | free(dup_str); | |
672 | return ret; | |
99d2c205 | 673 | } |
87b8530f | 674 | |
8faeb1d7 HS |
675 | int part_get_info_by_name(struct blk_desc *dev_desc, const char *name, |
676 | struct disk_partition *info) | |
87b8530f | 677 | { |
87b8530f | 678 | struct part_driver *part_drv; |
56670d6f KY |
679 | int ret; |
680 | int i; | |
681 | ||
682 | part_drv = part_driver_lookup_type(dev_desc); | |
683 | if (!part_drv) | |
684 | return -1; | |
50f7b2ef | 685 | |
686 | if (!part_drv->get_info) { | |
687 | log_debug("## Driver %s does not have the get_info() method\n", | |
688 | part_drv->name); | |
689 | return -ENOSYS; | |
690 | } | |
691 | ||
56670d6f KY |
692 | for (i = 1; i < part_drv->max_entries; i++) { |
693 | ret = part_drv->get_info(dev_desc, i, info); | |
694 | if (ret != 0) { | |
695 | /* no more entries in table */ | |
696 | break; | |
697 | } | |
698 | if (strcmp(name, (const char *)info->name) == 0) { | |
699 | /* matched */ | |
700 | return i; | |
87b8530f PK |
701 | } |
702 | } | |
56670d6f | 703 | |
59715754 | 704 | return -ENOENT; |
87b8530f | 705 | } |
da2ee24d | 706 | |
6eccd1f7 RT |
707 | /** |
708 | * Get partition info from device number and partition name. | |
709 | * | |
710 | * Parse a device number and partition name string in the form of | |
81c1aa89 SA |
711 | * "devicenum.hwpartnum#partition_name", for example "0.1#misc". devicenum and |
712 | * hwpartnum are both optional, defaulting to 0. If the partition is found, | |
713 | * sets dev_desc and part_info accordingly with the information of the | |
714 | * partition with the given partition_name. | |
6eccd1f7 RT |
715 | * |
716 | * @param[in] dev_iface Device interface | |
81c1aa89 | 717 | * @param[in] dev_part_str Input string argument, like "0.1#misc" |
6eccd1f7 RT |
718 | * @param[out] dev_desc Place to store the device description pointer |
719 | * @param[out] part_info Place to store the partition information | |
185f812c | 720 | * Return: 0 on success, or a negative on error |
6eccd1f7 RT |
721 | */ |
722 | static int part_get_info_by_dev_and_name(const char *dev_iface, | |
723 | const char *dev_part_str, | |
724 | struct blk_desc **dev_desc, | |
0528979f | 725 | struct disk_partition *part_info) |
6eccd1f7 | 726 | { |
81c1aa89 SA |
727 | char *dup_str = NULL; |
728 | const char *dev_str, *part_str; | |
729 | int ret; | |
6eccd1f7 | 730 | |
81c1aa89 | 731 | /* Separate device and partition name specification */ |
26de4296 SA |
732 | if (dev_part_str) |
733 | part_str = strchr(dev_part_str, '#'); | |
734 | else | |
735 | part_str = NULL; | |
736 | ||
81c1aa89 SA |
737 | if (part_str) { |
738 | dup_str = strdup(dev_part_str); | |
739 | dup_str[part_str - dev_part_str] = 0; | |
740 | dev_str = dup_str; | |
741 | part_str++; | |
742 | } else { | |
6eccd1f7 RT |
743 | return -EINVAL; |
744 | } | |
6eccd1f7 | 745 | |
81c1aa89 | 746 | ret = blk_get_device_by_str(dev_iface, dev_str, dev_desc); |
fe5a5091 | 747 | if (ret < 0) |
81c1aa89 SA |
748 | goto cleanup; |
749 | ||
59715754 SA |
750 | ret = part_get_info_by_name(*dev_desc, part_str, part_info); |
751 | if (ret < 0) | |
6eccd1f7 | 752 | printf("Could not find \"%s\" partition\n", part_str); |
81c1aa89 SA |
753 | |
754 | cleanup: | |
755 | free(dup_str); | |
59715754 | 756 | return ret; |
6eccd1f7 RT |
757 | } |
758 | ||
759 | int part_get_info_by_dev_and_name_or_num(const char *dev_iface, | |
760 | const char *dev_part_str, | |
761 | struct blk_desc **dev_desc, | |
9f7bb282 SA |
762 | struct disk_partition *part_info, |
763 | int allow_whole_dev) | |
6eccd1f7 | 764 | { |
59715754 SA |
765 | int ret; |
766 | ||
6eccd1f7 | 767 | /* Split the part_name if passed as "$dev_num#part_name". */ |
59715754 SA |
768 | ret = part_get_info_by_dev_and_name(dev_iface, dev_part_str, |
769 | dev_desc, part_info); | |
770 | if (ret >= 0) | |
771 | return ret; | |
6eccd1f7 RT |
772 | /* |
773 | * Couldn't lookup by name, try looking up the partition description | |
774 | * directly. | |
775 | */ | |
59715754 | 776 | ret = blk_get_device_part_str(dev_iface, dev_part_str, |
9f7bb282 | 777 | dev_desc, part_info, allow_whole_dev); |
59715754 | 778 | if (ret < 0) |
6eccd1f7 RT |
779 | printf("Couldn't find partition %s %s\n", |
780 | dev_iface, dev_part_str); | |
59715754 | 781 | return ret; |
6eccd1f7 RT |
782 | } |
783 | ||
da2ee24d PK |
784 | void part_set_generic_name(const struct blk_desc *dev_desc, |
785 | int part_num, char *name) | |
786 | { | |
787 | char *devtype; | |
788 | ||
8149b150 | 789 | switch (dev_desc->uclass_id) { |
e33a5c6b SG |
790 | case UCLASS_IDE: |
791 | case UCLASS_AHCI: | |
da2ee24d PK |
792 | devtype = "hd"; |
793 | break; | |
e33a5c6b | 794 | case UCLASS_SCSI: |
da2ee24d PK |
795 | devtype = "sd"; |
796 | break; | |
e33a5c6b | 797 | case UCLASS_USB: |
da2ee24d PK |
798 | devtype = "usbd"; |
799 | break; | |
e33a5c6b | 800 | case UCLASS_MMC: |
da2ee24d PK |
801 | devtype = "mmcsd"; |
802 | break; | |
803 | default: | |
804 | devtype = "xx"; | |
805 | break; | |
806 | } | |
807 | ||
808 | sprintf(name, "%s%c%d", devtype, 'a' + dev_desc->devnum, part_num); | |
809 | } | |
dcffa442 SG |
810 | |
811 | int part_get_bootable(struct blk_desc *desc) | |
812 | { | |
813 | struct disk_partition info; | |
814 | int p; | |
815 | ||
816 | for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) { | |
817 | int ret; | |
818 | ||
819 | ret = part_get_info(desc, p, &info); | |
820 | if (!ret && info.bootable) | |
821 | return p; | |
822 | } | |
823 | ||
824 | return 0; | |
825 | } |