]> git.ipfire.org Git - people/ms/u-boot.git/blame - disk/part.c
Merge git://git.denx.de/u-boot-x86
[people/ms/u-boot.git] / disk / part.c
CommitLineData
affae2bf
WD
1/*
2 * (C) Copyright 2001
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
1a459660 5 * SPDX-License-Identifier: GPL-2.0+
affae2bf
WD
6 */
7
8#include <common.h>
9#include <command.h>
96e5b03c 10#include <errno.h>
affae2bf 11#include <ide.h>
10a37fd7 12#include <malloc.h>
735dd97b 13#include <part.h>
251cee0d 14#include <ubifs_uboot.h>
affae2bf
WD
15
16#undef PART_DEBUG
17
18#ifdef PART_DEBUG
19#define PRINTF(fmt,args...) printf (fmt ,##args)
20#else
21#define PRINTF(fmt,args...)
22#endif
23
30789095
SP
24/* Check all partition types */
25#define PART_TYPE_ALL -1
26
751bb571 27DECLARE_GLOBAL_DATA_PTR;
751bb571 28
0c9c8fb5 29#ifdef HAVE_BLOCK_DEVICE
96e5b03c
SG
30static struct part_driver *part_driver_lookup_type(int part_type)
31{
32 struct part_driver *drv =
33 ll_entry_start(struct part_driver, part_driver);
34 const int n_ents = ll_entry_count(struct part_driver, part_driver);
35 struct part_driver *entry;
36
37 for (entry = drv; entry != drv + n_ents; entry++) {
38 if (part_type == entry->part_type)
39 return entry;
40 }
41
42 /* Not found */
43 return NULL;
44}
45
4101f687 46static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
735dd97b 47{
6dd9faf8
SG
48 struct blk_desc *dev_desc;
49 int ret;
735dd97b 50
6dd9faf8
SG
51 dev_desc = blk_get_devnum_by_typename(ifname, dev);
52 if (!dev_desc) {
53 debug("%s: No device for iface '%s', dev %d\n", __func__,
54 ifname, dev);
7e71dc68 55 return NULL;
735dd97b 56 }
6dd9faf8
SG
57 ret = blk_dselect_hwpart(dev_desc, hwpart);
58 if (ret) {
59 debug("%s: Failed to select h/w partition: err-%d\n", __func__,
60 ret);
61 return NULL;
62 }
63
64 return dev_desc;
735dd97b 65}
336b6f90 66
db1d9e78 67struct blk_desc *blk_get_dev(const char *ifname, int dev)
336b6f90 68{
ecdd57e2 69 return get_dev_hwpart(ifname, dev, 0);
336b6f90 70}
735dd97b 71#else
4101f687 72struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
336b6f90
SW
73{
74 return NULL;
75}
76
db1d9e78 77struct blk_desc *blk_get_dev(const char *ifname, int dev)
735dd97b
GL
78{
79 return NULL;
80}
81#endif
82
0c9c8fb5 83#ifdef HAVE_BLOCK_DEVICE
affae2bf
WD
84
85/* ------------------------------------------------------------------------- */
86/*
87 * reports device info to the user
88 */
69a2a4d9 89
42dfe7a1 90#ifdef CONFIG_LBA48
69a2a4d9 91typedef uint64_t lba512_t;
c40b2956 92#else
69a2a4d9 93typedef lbaint_t lba512_t;
c40b2956 94#endif
affae2bf 95
69a2a4d9
ST
96/*
97 * Overflowless variant of (block_count * mul_by / div_by)
98 * when div_by > mul_by
99 */
214b3f31 100static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by, lba512_t div_by)
69a2a4d9
ST
101{
102 lba512_t bc_quot, bc_rem;
103
104 /* x * m / d == x / d * m + (x % d) * m / d */
105 bc_quot = block_count / div_by;
106 bc_rem = block_count - div_by * bc_quot;
107 return bc_quot * mul_by + (bc_rem * mul_by) / div_by;
108}
109
4101f687 110void dev_print (struct blk_desc *dev_desc)
69a2a4d9
ST
111{
112 lba512_t lba512; /* number of blocks if 512bytes block size */
113
af75a45d
WD
114 if (dev_desc->type == DEV_TYPE_UNKNOWN) {
115 puts ("not available\n");
116 return;
117 }
118
8ec6e332 119 switch (dev_desc->if_type) {
574b3195
DZ
120 case IF_TYPE_SCSI:
121 printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n",
122 dev_desc->target,dev_desc->lun,
affae2bf 123 dev_desc->vendor,
574b3195
DZ
124 dev_desc->product,
125 dev_desc->revision);
126 break;
6e24a1eb 127 case IF_TYPE_ATAPI:
574b3195
DZ
128 case IF_TYPE_IDE:
129 case IF_TYPE_SATA:
c7057b52
DL
130 printf ("Model: %s Firm: %s Ser#: %s\n",
131 dev_desc->vendor,
132 dev_desc->revision,
133 dev_desc->product);
574b3195 134 break;
6e24a1eb
RB
135 case IF_TYPE_SD:
136 case IF_TYPE_MMC:
47bebe34 137 case IF_TYPE_USB:
ffab6945 138 case IF_TYPE_NVME:
47bebe34
NCL
139 printf ("Vendor: %s Rev: %s Prod: %s\n",
140 dev_desc->vendor,
141 dev_desc->revision,
142 dev_desc->product);
143 break;
6e24a1eb
RB
144 case IF_TYPE_DOC:
145 puts("device type DOC\n");
146 return;
8ec6e332 147 case IF_TYPE_UNKNOWN:
6e24a1eb
RB
148 puts("device type unknown\n");
149 return;
574b3195 150 default:
6e24a1eb 151 printf("Unhandled device type: %i\n", dev_desc->if_type);
574b3195 152 return;
affae2bf
WD
153 }
154 puts (" Type: ");
155 if (dev_desc->removable)
156 puts ("Removable ");
157 switch (dev_desc->type & 0x1F) {
726c0f1e
DZ
158 case DEV_TYPE_HARDDISK:
159 puts ("Hard Disk");
160 break;
161 case DEV_TYPE_CDROM:
162 puts ("CD ROM");
163 break;
164 case DEV_TYPE_OPDISK:
165 puts ("Optical Device");
166 break;
167 case DEV_TYPE_TAPE:
168 puts ("Tape");
169 break;
170 default:
171 printf ("# %02X #", dev_desc->type & 0x1F);
172 break;
affae2bf
WD
173 }
174 puts ("\n");
33699df1 175 if (dev_desc->lba > 0L && dev_desc->blksz > 0L) {
affae2bf 176 ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;
c40b2956 177 lbaint_t lba;
6e592385
WD
178
179 lba = dev_desc->lba;
affae2bf 180
c40b2956 181 lba512 = (lba * (dev_desc->blksz/512));
affae2bf 182 /* round to 1 digit */
214b3f31
PM
183 /* 2048 = (1024 * 1024) / 512 MB */
184 mb = lba512_muldiv(lba512, 10, 2048);
69a2a4d9 185
affae2bf
WD
186 mb_quot = mb / 10;
187 mb_rem = mb - (10 * mb_quot);
188
189 gb = mb / 1024;
190 gb_quot = gb / 10;
191 gb_rem = gb - (10 * gb_quot);
42dfe7a1 192#ifdef CONFIG_LBA48
6e592385 193 if (dev_desc->lba48)
c40b2956
WD
194 printf (" Supports 48-bit addressing\n");
195#endif
4b142feb 196#if defined(CONFIG_SYS_64BIT_LBA)
139f7b1d 197 printf (" Capacity: %lu.%lu MB = %lu.%lu GB (%llu x %lu)\n",
c40b2956
WD
198 mb_quot, mb_rem,
199 gb_quot, gb_rem,
200 lba,
201 dev_desc->blksz);
202#else
139f7b1d 203 printf (" Capacity: %lu.%lu MB = %lu.%lu GB (%lu x %lu)\n",
affae2bf
WD
204 mb_quot, mb_rem,
205 gb_quot, gb_rem,
c40b2956 206 (ulong)lba,
affae2bf 207 dev_desc->blksz);
c40b2956 208#endif
affae2bf
WD
209 } else {
210 puts (" Capacity: not available\n");
211 }
212}
b3aff0cb 213#endif
affae2bf 214
0c9c8fb5 215#ifdef HAVE_BLOCK_DEVICE
affae2bf 216
3e8bd469 217void part_init(struct blk_desc *dev_desc)
affae2bf 218{
96e5b03c
SG
219 struct part_driver *drv =
220 ll_entry_start(struct part_driver, part_driver);
221 const int n_ents = ll_entry_count(struct part_driver, part_driver);
222 struct part_driver *entry;
affae2bf 223
e40cf34a
EN
224 blkcache_invalidate(dev_desc->if_type, dev_desc->devnum);
225
99d2c205 226 dev_desc->part_type = PART_TYPE_UNKNOWN;
96e5b03c
SG
227 for (entry = drv; entry != drv + n_ents; entry++) {
228 int ret;
229
230 ret = entry->test(dev_desc);
231 debug("%s: try '%s': ret=%d\n", __func__, entry->name, ret);
232 if (!ret) {
233 dev_desc->part_type = entry->part_type;
234 break;
235 }
236 }
affae2bf
WD
237}
238
96e5b03c
SG
239static void print_part_header(const char *type, struct blk_desc *dev_desc)
240{
f18fa31c 241#if CONFIG_IS_ENABLED(MAC_PARTITION) || \
b0cf7339 242 CONFIG_IS_ENABLED(DOS_PARTITION) || \
1acc0087 243 CONFIG_IS_ENABLED(ISO_PARTITION) || \
863c5b6c 244 CONFIG_IS_ENABLED(AMIGA_PARTITION) || \
bd42a942 245 CONFIG_IS_ENABLED(EFI_PARTITION)
affae2bf
WD
246 puts ("\nPartition Map for ");
247 switch (dev_desc->if_type) {
726c0f1e
DZ
248 case IF_TYPE_IDE:
249 puts ("IDE");
250 break;
251 case IF_TYPE_SATA:
252 puts ("SATA");
253 break;
254 case IF_TYPE_SCSI:
255 puts ("SCSI");
256 break;
257 case IF_TYPE_ATAPI:
258 puts ("ATAPI");
259 break;
260 case IF_TYPE_USB:
261 puts ("USB");
262 break;
263 case IF_TYPE_DOC:
264 puts ("DOC");
265 break;
8f3b9642
LW
266 case IF_TYPE_MMC:
267 puts ("MMC");
268 break;
f4d8de48 269 case IF_TYPE_HOST:
ffab6945
ZZ
270 puts ("HOST");
271 break;
272 case IF_TYPE_NVME:
273 puts ("NVMe");
f4d8de48 274 break;
726c0f1e
DZ
275 default:
276 puts ("UNKNOWN");
277 break;
affae2bf
WD
278 }
279 printf (" device %d -- Partition Type: %s\n\n",
bcce53d0 280 dev_desc->devnum, type);
0c9c8fb5 281#endif /* any CONFIG_..._PARTITION */
96e5b03c 282}
0c9c8fb5 283
3e8bd469 284void part_print(struct blk_desc *dev_desc)
affae2bf 285{
96e5b03c 286 struct part_driver *drv;
affae2bf 287
96e5b03c
SG
288 drv = part_driver_lookup_type(dev_desc->part_type);
289 if (!drv) {
290 printf("## Unknown partition table type %x\n",
291 dev_desc->part_type);
affae2bf 292 return;
affae2bf 293 }
96e5b03c
SG
294
295 PRINTF("## Testing for valid %s partition ##\n", drv->name);
296 print_part_header(drv->name, dev_desc);
297 if (drv->print)
298 drv->print(dev_desc);
affae2bf
WD
299}
300
0c9c8fb5 301#endif /* HAVE_BLOCK_DEVICE */
2f501646 302
3e8bd469 303int part_get_info(struct blk_desc *dev_desc, int part,
3f9eb6e1 304 disk_partition_t *info)
2f501646 305{
0c9c8fb5 306#ifdef HAVE_BLOCK_DEVICE
96e5b03c 307 struct part_driver *drv;
2f501646 308
b331cd62 309#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
894bfbbf
SW
310 /* The common case is no UUID support */
311 info->uuid[0] = 0;
312#endif
7561b258
PD
313#ifdef CONFIG_PARTITION_TYPE_GUID
314 info->type_guid[0] = 0;
315#endif
894bfbbf 316
96e5b03c
SG
317 drv = part_driver_lookup_type(dev_desc->part_type);
318 if (!drv) {
319 debug("## Unknown partition table type %x\n",
320 dev_desc->part_type);
321 return -EPROTONOSUPPORT;
322 }
323 if (!drv->get_info) {
2ae67aec
NM
324 PRINTF("## Driver %s does not have the get_info() method\n",
325 drv->name);
96e5b03c
SG
326 return -ENOSYS;
327 }
328 if (drv->get_info(dev_desc, part, info) == 0) {
329 PRINTF("## Valid %s partition found ##\n", drv->name);
330 return 0;
2f501646 331 }
0c9c8fb5 332#endif /* HAVE_BLOCK_DEVICE */
2f501646
SW
333
334 return -1;
335}
99d2c205 336
4bbcc965
RC
337int part_get_info_whole_disk(struct blk_desc *dev_desc, disk_partition_t *info)
338{
339 info->start = 0;
340 info->size = dev_desc->lba;
341 info->blksz = dev_desc->blksz;
342 info->bootable = 0;
343 strcpy((char *)info->type, BOOT_PART_TYPE);
344 strcpy((char *)info->name, "Whole Disk");
345#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
346 info->uuid[0] = 0;
347#endif
348#ifdef CONFIG_PARTITION_TYPE_GUID
349 info->type_guid[0] = 0;
350#endif
351
352 return 0;
353}
354
ebac37cf
SG
355int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str,
356 struct blk_desc **dev_desc)
2023e608
SW
357{
358 char *ep;
336b6f90
SW
359 char *dup_str = NULL;
360 const char *dev_str, *hwpart_str;
361 int dev, hwpart;
362
363 hwpart_str = strchr(dev_hwpart_str, '.');
364 if (hwpart_str) {
365 dup_str = strdup(dev_hwpart_str);
366 dup_str[hwpart_str - dev_hwpart_str] = 0;
367 dev_str = dup_str;
368 hwpart_str++;
369 } else {
370 dev_str = dev_hwpart_str;
ecdd57e2 371 hwpart = 0;
336b6f90 372 }
2023e608
SW
373
374 dev = simple_strtoul(dev_str, &ep, 16);
375 if (*ep) {
376 printf("** Bad device specification %s %s **\n",
377 ifname, dev_str);
1598dfcb 378 dev = -EINVAL;
336b6f90
SW
379 goto cleanup;
380 }
381
382 if (hwpart_str) {
383 hwpart = simple_strtoul(hwpart_str, &ep, 16);
384 if (*ep) {
385 printf("** Bad HW partition specification %s %s **\n",
386 ifname, hwpart_str);
1598dfcb 387 dev = -EINVAL;
336b6f90
SW
388 goto cleanup;
389 }
2023e608
SW
390 }
391
336b6f90 392 *dev_desc = get_dev_hwpart(ifname, dev, hwpart);
2023e608 393 if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) {
336b6f90 394 printf("** Bad device %s %s **\n", ifname, dev_hwpart_str);
1598dfcb 395 dev = -ENOENT;
336b6f90 396 goto cleanup;
2023e608
SW
397 }
398
99e7fc8a
ET
399#ifdef HAVE_BLOCK_DEVICE
400 /*
401 * Updates the partition table for the specified hw partition.
402 * Does not need to be done for hwpart 0 since it is default and
403 * already loaded.
404 */
405 if(hwpart != 0)
3e8bd469 406 part_init(*dev_desc);
99e7fc8a
ET
407#endif
408
336b6f90
SW
409cleanup:
410 free(dup_str);
2023e608
SW
411 return dev;
412}
413
10a37fd7
SW
414#define PART_UNSPECIFIED -2
415#define PART_AUTO -1
e35929e4 416int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
4101f687 417 struct blk_desc **dev_desc,
10a37fd7 418 disk_partition_t *info, int allow_whole_dev)
99d2c205 419{
10a37fd7
SW
420 int ret = -1;
421 const char *part_str;
422 char *dup_str = NULL;
423 const char *dev_str;
99d2c205 424 int dev;
10a37fd7
SW
425 char *ep;
426 int p;
427 int part;
428 disk_partition_t tmpinfo;
429
afc1744e 430#ifdef CONFIG_SANDBOX
4d907025 431 /*
3f9eb6e1 432 * Special-case a pseudo block device "hostfs", to allow access to the
4d907025
SW
433 * host's own filesystem.
434 */
435 if (0 == strcmp(ifname, "hostfs")) {
436 *dev_desc = NULL;
437 info->start = 0;
438 info->size = 0;
439 info->blksz = 0;
440 info->bootable = 0;
441 strcpy((char *)info->type, BOOT_PART_TYPE);
442 strcpy((char *)info->name, "Sandbox host");
b331cd62 443#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
4d907025
SW
444 info->uuid[0] = 0;
445#endif
7561b258
PD
446#ifdef CONFIG_PARTITION_TYPE_GUID
447 info->type_guid[0] = 0;
448#endif
4d907025
SW
449
450 return 0;
451 }
afc1744e 452#endif
4d907025 453
251cee0d
HG
454#ifdef CONFIG_CMD_UBIFS
455 /*
456 * Special-case ubi, ubi goes through a mtd, rathen then through
457 * a regular block device.
458 */
459 if (0 == strcmp(ifname, "ubi")) {
460 if (!ubifs_is_mounted()) {
461 printf("UBIFS not mounted, use ubifsmount to mount volume first!\n");
462 return -1;
463 }
464
465 *dev_desc = NULL;
466 memset(info, 0, sizeof(*info));
467 strcpy((char *)info->type, BOOT_PART_TYPE);
468 strcpy((char *)info->name, "UBI");
b331cd62 469#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
251cee0d
HG
470 info->uuid[0] = 0;
471#endif
472 return 0;
473 }
474#endif
475
10a37fd7 476 /* If no dev_part_str, use bootdevice environment variable */
a10973e7
SW
477 if (!dev_part_str || !strlen(dev_part_str) ||
478 !strcmp(dev_part_str, "-"))
00caae6d 479 dev_part_str = env_get("bootdevice");
10a37fd7
SW
480
481 /* If still no dev_part_str, it's an error */
482 if (!dev_part_str) {
483 printf("** No device specified **\n");
484 goto cleanup;
485 }
486
487 /* Separate device and partition ID specification */
488 part_str = strchr(dev_part_str, ':');
489 if (part_str) {
490 dup_str = strdup(dev_part_str);
491 dup_str[part_str - dev_part_str] = 0;
492 dev_str = dup_str;
493 part_str++;
494 } else {
495 dev_str = dev_part_str;
99d2c205
RH
496 }
497
10a37fd7 498 /* Look up the device */
ebac37cf 499 dev = blk_get_device_by_str(ifname, dev_str, dev_desc);
10a37fd7
SW
500 if (dev < 0)
501 goto cleanup;
502
503 /* Convert partition ID string to number */
504 if (!part_str || !*part_str) {
505 part = PART_UNSPECIFIED;
506 } else if (!strcmp(part_str, "auto")) {
507 part = PART_AUTO;
508 } else {
509 /* Something specified -> use exactly that */
510 part = (int)simple_strtoul(part_str, &ep, 16);
511 /*
512 * Less than whole string converted,
513 * or request for whole device, but caller requires partition.
514 */
515 if (*ep || (part == 0 && !allow_whole_dev)) {
516 printf("** Bad partition specification %s %s **\n",
517 ifname, dev_part_str);
518 goto cleanup;
519 }
520 }
521
522 /*
523 * No partition table on device,
524 * or user requested partition 0 (entire device).
525 */
526 if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) ||
527 (part == 0)) {
528 if (!(*dev_desc)->lba) {
529 printf("** Bad device size - %s %s **\n", ifname,
530 dev_str);
531 goto cleanup;
532 }
99d2c205 533
10a37fd7
SW
534 /*
535 * If user specified a partition ID other than 0,
536 * or the calling command only accepts partitions,
537 * it's an error.
538 */
539 if ((part > 0) || (!allow_whole_dev)) {
540 printf("** No partition table - %s %s **\n", ifname,
541 dev_str);
542 goto cleanup;
99d2c205 543 }
10a37fd7 544
50ffc3b6
LY
545 (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
546
4bbcc965 547 part_get_info_whole_disk(*dev_desc, info);
99d2c205 548
10a37fd7
SW
549 ret = 0;
550 goto cleanup;
99d2c205
RH
551 }
552
10a37fd7
SW
553 /*
554 * Now there's known to be a partition table,
555 * not specifying a partition means to pick partition 1.
556 */
557 if (part == PART_UNSPECIFIED)
558 part = 1;
559
560 /*
561 * If user didn't specify a partition number, or did specify something
562 * other than "auto", use that partition number directly.
563 */
564 if (part != PART_AUTO) {
3e8bd469 565 ret = part_get_info(*dev_desc, part, info);
10a37fd7
SW
566 if (ret) {
567 printf("** Invalid partition %d **\n", part);
568 goto cleanup;
569 }
570 } else {
571 /*
572 * Find the first bootable partition.
573 * If none are bootable, fall back to the first valid partition.
574 */
575 part = 0;
576 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
3e8bd469 577 ret = part_get_info(*dev_desc, p, info);
10a37fd7
SW
578 if (ret)
579 continue;
580
581 /*
582 * First valid partition, or new better partition?
583 * If so, save partition ID.
584 */
585 if (!part || info->bootable)
586 part = p;
587
588 /* Best possible partition? Stop searching. */
589 if (info->bootable)
590 break;
591
592 /*
593 * We now need to search further for best possible.
594 * If we what we just queried was the best so far,
595 * save the info since we over-write it next loop.
596 */
597 if (part == p)
598 tmpinfo = *info;
599 }
600 /* If we found any acceptable partition */
601 if (part) {
602 /*
603 * If we searched all possible partition IDs,
604 * return the first valid partition we found.
605 */
606 if (p == MAX_SEARCH_PARTITIONS + 1)
607 *info = tmpinfo;
10a37fd7
SW
608 } else {
609 printf("** No valid partitions found **\n");
71bba424 610 ret = -1;
10a37fd7
SW
611 goto cleanup;
612 }
99d2c205
RH
613 }
614 if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) {
615 printf("** Invalid partition type \"%.32s\""
616 " (expect \"" BOOT_PART_TYPE "\")\n",
617 info->type);
10a37fd7
SW
618 ret = -1;
619 goto cleanup;
99d2c205
RH
620 }
621
50ffc3b6
LY
622 (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
623
10a37fd7
SW
624 ret = part;
625 goto cleanup;
99d2c205 626
10a37fd7
SW
627cleanup:
628 free(dup_str);
629 return ret;
99d2c205 630}
87b8530f 631
30789095
SP
632int part_get_info_by_name_type(struct blk_desc *dev_desc, const char *name,
633 disk_partition_t *info, int part_type)
87b8530f
PK
634{
635 struct part_driver *first_drv =
636 ll_entry_start(struct part_driver, part_driver);
637 const int n_drvs = ll_entry_count(struct part_driver, part_driver);
638 struct part_driver *part_drv;
639
640 for (part_drv = first_drv; part_drv != first_drv + n_drvs; part_drv++) {
641 int ret;
642 int i;
643 for (i = 1; i < part_drv->max_entries; i++) {
30789095
SP
644 if (part_type >= 0 && part_type != part_drv->part_type)
645 break;
87b8530f
PK
646 ret = part_drv->get_info(dev_desc, i, info);
647 if (ret != 0) {
648 /* no more entries in table */
649 break;
650 }
651 if (strcmp(name, (const char *)info->name) == 0) {
652 /* matched */
88b6329c 653 return i;
87b8530f
PK
654 }
655 }
656 }
657 return -1;
658}
da2ee24d 659
30789095
SP
660int part_get_info_by_name(struct blk_desc *dev_desc, const char *name,
661 disk_partition_t *info)
662{
663 return part_get_info_by_name_type(dev_desc, name, info, PART_TYPE_ALL);
664}
665
da2ee24d
PK
666void part_set_generic_name(const struct blk_desc *dev_desc,
667 int part_num, char *name)
668{
669 char *devtype;
670
671 switch (dev_desc->if_type) {
672 case IF_TYPE_IDE:
673 case IF_TYPE_SATA:
674 case IF_TYPE_ATAPI:
675 devtype = "hd";
676 break;
677 case IF_TYPE_SCSI:
678 devtype = "sd";
679 break;
680 case IF_TYPE_USB:
681 devtype = "usbd";
682 break;
683 case IF_TYPE_DOC:
684 devtype = "docd";
685 break;
686 case IF_TYPE_MMC:
687 case IF_TYPE_SD:
688 devtype = "mmcsd";
689 break;
690 default:
691 devtype = "xx";
692 break;
693 }
694
695 sprintf(name, "%s%c%d", devtype, 'a' + dev_desc->devnum, part_num);
696}