disk/part.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2001
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  */
   6
   7 #include <common.h>
   8 #include <blk.h>
   9 #include <command.h>
  10 #include <env.h>
  11 #include <errno.h>
  12 #include <ide.h>
  13 #include <log.h>
  14 #include <malloc.h>
  15 #include <part.h>
  16 #include <ubifs_uboot.h>
  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
  26 /* Check all partition types */
  27 #define PART_TYPE_ALL           -1
  28
  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
  45 static struct part_driver *part_driver_lookup_type(struct blk_desc *dev_desc)
  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
  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 {
  63                 return part_driver_get_type(dev_desc->part_type);
  64         }
  65
  66         /* Not found */
  67         return NULL;
  68 }
  69
  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
  86 static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
  87 {
  88         struct blk_desc *dev_desc;
  89         int ret;
  90
  91         if (!blk_enabled())
  92                 return NULL;
  93         dev_desc = blk_get_devnum_by_uclass_idname(ifname, dev);
  94         if (!dev_desc) {
  95                 debug("%s: No device for iface '%s', dev %d\n", __func__,
  96                       ifname, dev);
  97                 return NULL;
  98         }
  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;
 107 }
 108
 109 struct blk_desc *blk_get_dev(const char *ifname, int dev)
 110 {
 111         if (!blk_enabled())
 112                 return NULL;
 113
 114         return get_dev_hwpart(ifname, dev, 0);
 115 }
 116
 117 /* ------------------------------------------------------------------------- */
 118 /*
 119  * reports device info to the user
 120  */
 121
 122 #ifdef CONFIG_LBA48
 123 typedef uint64_t lba512_t;
 124 #else
 125 typedef lbaint_t lba512_t;
 126 #endif
 127
 128 /*
 129  * Overflowless variant of (block_count * mul_by / 2**right_shift)
 130  * when 2**right_shift > mul_by
 131  */
 132 static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by,
 133                               int right_shift)
 134 {
 135         lba512_t bc_quot, bc_rem;
 136
 137         /* x * m / d == x / d * m + (x % d) * m / d */
 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);
 141 }
 142
 143 void dev_print(struct blk_desc *dev_desc)
 144 {
 145         lba512_t lba512; /* number of blocks if 512bytes block size */
 146
 147         if (dev_desc->type == DEV_TYPE_UNKNOWN) {
 148                 puts ("not available\n");
 149                 return;
 150         }
 151
 152         switch (dev_desc->uclass_id) {
 153         case UCLASS_SCSI:
 154                 printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n",
 155                         dev_desc->target,dev_desc->lun,
 156                         dev_desc->vendor,
 157                         dev_desc->product,
 158                         dev_desc->revision);
 159                 break;
 160         case UCLASS_IDE:
 161         case UCLASS_AHCI:
 162                 printf ("Model: %s Firm: %s Ser#: %s\n",
 163                         dev_desc->vendor,
 164                         dev_desc->revision,
 165                         dev_desc->product);
 166                 break;
 167         case UCLASS_MMC:
 168         case UCLASS_USB:
 169         case UCLASS_NVME:
 170         case UCLASS_PVBLOCK:
 171         case UCLASS_HOST:
 172         case UCLASS_BLKMAP:
 173                 printf ("Vendor: %s Rev: %s Prod: %s\n",
 174                         dev_desc->vendor,
 175                         dev_desc->revision,
 176                         dev_desc->product);
 177                 break;
 178         case UCLASS_VIRTIO:
 179                 printf("%s VirtIO Block Device\n", dev_desc->vendor);
 180                 break;
 181         case UCLASS_EFI_MEDIA:
 182                 printf("EFI media Block Device %d\n", dev_desc->devnum);
 183                 break;
 184         case UCLASS_INVALID:
 185                 puts("device type unknown\n");
 186                 return;
 187         default:
 188                 printf("Unhandled device type: %i\n", dev_desc->uclass_id);
 189                 return;
 190         }
 191         puts ("            Type: ");
 192         if (dev_desc->removable)
 193                 puts ("Removable ");
 194         switch (dev_desc->type & 0x1F) {
 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;
 210         }
 211         puts ("\n");
 212         if (dev_desc->lba > 0L && dev_desc->blksz > 0L) {
 213                 ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;
 214                 lbaint_t lba;
 215
 216                 lba = dev_desc->lba;
 217
 218                 lba512 = (lba * (dev_desc->blksz/512));
 219                 /* round to 1 digit */
 220                 /* 2048 = (1024 * 1024) / 512 MB */
 221                 mb = lba512_muldiv(lba512, 10, 11);
 222
 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);
 229 #ifdef CONFIG_LBA48
 230                 if (dev_desc->lba48)
 231                         printf ("            Supports 48-bit addressing\n");
 232 #endif
 233 #if defined(CONFIG_SYS_64BIT_LBA)
 234                 printf ("            Capacity: %lu.%lu MB = %lu.%lu GB (%llu x %lu)\n",
 235                         mb_quot, mb_rem,
 236                         gb_quot, gb_rem,
 237                         lba,
 238                         dev_desc->blksz);
 239 #else
 240                 printf ("            Capacity: %lu.%lu MB = %lu.%lu GB (%lu x %lu)\n",
 241                         mb_quot, mb_rem,
 242                         gb_quot, gb_rem,
 243                         (ulong)lba,
 244                         dev_desc->blksz);
 245 #endif
 246         } else {
 247                 puts ("            Capacity: not available\n");
 248         }
 249 }
 250
 251 void part_init(struct blk_desc *dev_desc)
 252 {
 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;
 257
 258         blkcache_invalidate(dev_desc->uclass_id, dev_desc->devnum);
 259
 260         dev_desc->part_type = PART_TYPE_UNKNOWN;
 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         }
 271 }
 272
 273 static void print_part_header(const char *type, struct blk_desc *dev_desc)
 274 {
 275 #if CONFIG_IS_ENABLED(MAC_PARTITION) || \
 276         CONFIG_IS_ENABLED(DOS_PARTITION) || \
 277         CONFIG_IS_ENABLED(ISO_PARTITION) || \
 278         CONFIG_IS_ENABLED(AMIGA_PARTITION) || \
 279         CONFIG_IS_ENABLED(EFI_PARTITION)
 280         puts ("\nPartition Map for ");
 281         switch (dev_desc->uclass_id) {
 282         case UCLASS_IDE:
 283                 puts ("IDE");
 284                 break;
 285         case UCLASS_AHCI:
 286                 puts ("SATA");
 287                 break;
 288         case UCLASS_SCSI:
 289                 puts ("SCSI");
 290                 break;
 291         case UCLASS_USB:
 292                 puts ("USB");
 293                 break;
 294         case UCLASS_MMC:
 295                 puts ("MMC");
 296                 break;
 297         case UCLASS_HOST:
 298                 puts ("HOST");
 299                 break;
 300         case UCLASS_NVME:
 301                 puts ("NVMe");
 302                 break;
 303         case UCLASS_PVBLOCK:
 304                 puts("PV BLOCK");
 305                 break;
 306         case UCLASS_VIRTIO:
 307                 puts("VirtIO");
 308                 break;
 309         case UCLASS_EFI_MEDIA:
 310                 puts("EFI");
 311                 break;
 312         default:
 313                 puts("UNKNOWN");
 314                 break;
 315         }
 316         printf (" device %d  --   Partition Type: %s\n\n",
 317                         dev_desc->devnum, type);
 318 #endif /* any CONFIG_..._PARTITION */
 319 }
 320
 321 void part_print(struct blk_desc *dev_desc)
 322 {
 323         struct part_driver *drv;
 324
 325         drv = part_driver_lookup_type(dev_desc);
 326         if (!drv) {
 327                 printf("## Unknown partition table type %x\n",
 328                        dev_desc->part_type);
 329                 return;
 330         }
 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);
 336 }
 337
 338 int part_get_info_by_type(struct blk_desc *dev_desc, int part, int part_type,
 339                           struct disk_partition *info)
 340 {
 341         struct part_driver *drv;
 342
 343         if (blk_enabled()) {
 344 #if CONFIG_IS_ENABLED(PARTITION_UUIDS)
 345                 /* The common case is no UUID support */
 346                 info->uuid[0] = 0;
 347 #endif
 348 #ifdef CONFIG_PARTITION_TYPE_GUID
 349                 info->type_guid[0] = 0;
 350 #endif
 351
 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
 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                 }
 372         }
 373
 374         return -ENOENT;
 375 }
 376
 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
 383 int part_get_info_whole_disk(struct blk_desc *dev_desc,
 384                              struct disk_partition *info)
 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
 402 int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str,
 403                           struct blk_desc **dev_desc)
 404 {
 405         char *ep;
 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;
 418                 hwpart = 0;
 419         }
 420
 421         dev = hextoul(dev_str, &ep);
 422         if (*ep) {
 423                 printf("** Bad device specification %s %s **\n",
 424                        ifname, dev_str);
 425                 dev = -EINVAL;
 426                 goto cleanup;
 427         }
 428
 429         if (hwpart_str) {
 430                 hwpart = hextoul(hwpart_str, &ep);
 431                 if (*ep) {
 432                         printf("** Bad HW partition specification %s %s **\n",
 433                             ifname, hwpart_str);
 434                         dev = -EINVAL;
 435                         goto cleanup;
 436                 }
 437         }
 438
 439         *dev_desc = get_dev_hwpart(ifname, dev, hwpart);
 440         if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) {
 441                 debug("** Bad device %s %s **\n", ifname, dev_hwpart_str);
 442                 dev = -ENODEV;
 443                 goto cleanup;
 444         }
 445
 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                  */
 452                 if ((*dev_desc)->uclass_id == UCLASS_MMC)
 453                         part_init(*dev_desc);
 454         }
 455
 456 cleanup:
 457         free(dup_str);
 458         return dev;
 459 }
 460
 461 #define PART_UNSPECIFIED -2
 462 #define PART_AUTO -1
 463 int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
 464                              struct blk_desc **dev_desc,
 465                              struct disk_partition *info, int allow_whole_dev)
 466 {
 467         int ret;
 468         const char *part_str;
 469         char *dup_str = NULL;
 470         const char *dev_str;
 471         int dev;
 472         char *ep;
 473         int p;
 474         int part;
 475         struct disk_partition tmpinfo;
 476
 477         *dev_desc = NULL;
 478         memset(info, 0, sizeof(*info));
 479
 480 #if IS_ENABLED(CONFIG_SANDBOX) || IS_ENABLED(CONFIG_SEMIHOSTING)
 481         /*
 482          * Special-case a pseudo block device "hostfs", to allow access to the
 483          * host's own filesystem.
 484          */
 485         if (!strcmp(ifname, "hostfs")) {
 486                 strcpy((char *)info->type, BOOT_PART_TYPE);
 487                 strcpy((char *)info->name, "Host filesystem");
 488
 489                 return 0;
 490         }
 491 #endif
 492
 493 #if IS_ENABLED(CONFIG_CMD_UBIFS) && !IS_ENABLED(CONFIG_SPL_BUILD)
 494         /*
 495          * Special-case ubi, ubi goes through a mtd, rather than through
 496          * a regular block device.
 497          */
 498         if (!strcmp(ifname, "ubi")) {
 499                 if (!ubifs_is_mounted()) {
 500                         printf("UBIFS not mounted, use ubifsmount to mount volume first!\n");
 501                         return -EINVAL;
 502                 }
 503
 504                 strcpy((char *)info->type, BOOT_PART_TYPE);
 505                 strcpy((char *)info->name, "UBI");
 506                 return 0;
 507         }
 508 #endif
 509
 510         /* If no dev_part_str, use bootdevice environment variable */
 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         }
 516
 517         /* If still no dev_part_str, it's an error */
 518         if (!dev_part_str) {
 519                 printf("** No device specified **\n");
 520                 ret = -ENODEV;
 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;
 533         }
 534
 535         /* Look up the device */
 536         dev = blk_get_device_by_str(ifname, dev_str, dev_desc);
 537         if (dev < 0) {
 538                 printf("** Bad device specification %s %s **\n",
 539                        ifname, dev_str);
 540                 ret = dev;
 541                 goto cleanup;
 542         }
 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 */
 551                 part = (int)hextoul(part_str, &ep);
 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);
 559                         ret = -ENOENT;
 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);
 573                         ret = -EINVAL;
 574                         goto cleanup;
 575                 }
 576
 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);
 585                         ret = -EPROTONOSUPPORT;
 586                         goto cleanup;
 587                 }
 588
 589                 (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
 590
 591                 part_get_info_whole_disk(*dev_desc, info);
 592
 593                 ret = 0;
 594                 goto cleanup;
 595         }
 596
 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) {
 609                 ret = part_get_info(*dev_desc, part, info);
 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++) {
 621                         ret = part_get_info(*dev_desc, p, info);
 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;
 652                 } else {
 653                         printf("** No valid partitions found **\n");
 654                         goto cleanup;
 655                 }
 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);
 661                 ret  = -EINVAL;
 662                 goto cleanup;
 663         }
 664
 665         (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
 666
 667         ret = part;
 668         goto cleanup;
 669
 670 cleanup:
 671         free(dup_str);
 672         return ret;
 673 }
 674
 675 int part_get_info_by_name(struct blk_desc *dev_desc, const char *name,
 676                           struct disk_partition *info)
 677 {
 678         struct part_driver *part_drv;
 679         int ret;
 680         int i;
 681
 682         part_drv = part_driver_lookup_type(dev_desc);
 683         if (!part_drv)
 684                 return -1;
 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
 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;
 701                 }
 702         }
 703
 704         return -ENOENT;
 705 }
 706
 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
 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.
 715  *
 716  * @param[in] dev_iface Device interface
 717  * @param[in] dev_part_str Input string argument, like "0.1#misc"
 718  * @param[out] dev_desc Place to store the device description pointer
 719  * @param[out] part_info Place to store the partition information
 720  * Return: 0 on success, or a negative on error
 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,
 725                                          struct disk_partition *part_info)
 726 {
 727         char *dup_str = NULL;
 728         const char *dev_str, *part_str;
 729         int ret;
 730
 731         /* Separate device and partition name specification */
 732         if (dev_part_str)
 733                 part_str = strchr(dev_part_str, '#');
 734         else
 735                 part_str = NULL;
 736
 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 {
 743                 return -EINVAL;
 744         }
 745
 746         ret = blk_get_device_by_str(dev_iface, dev_str, dev_desc);
 747         if (ret < 0)
 748                 goto cleanup;
 749
 750         ret = part_get_info_by_name(*dev_desc, part_str, part_info);
 751         if (ret < 0)
 752                 printf("Could not find \"%s\" partition\n", part_str);
 753
 754 cleanup:
 755         free(dup_str);
 756         return ret;
 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,
 762                                          struct disk_partition *part_info,
 763                                          int allow_whole_dev)
 764 {
 765         int ret;
 766
 767         /* Split the part_name if passed as "$dev_num#part_name". */
 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;
 772         /*
 773          * Couldn't lookup by name, try looking up the partition description
 774          * directly.
 775          */
 776         ret = blk_get_device_part_str(dev_iface, dev_part_str,
 777                                       dev_desc, part_info, allow_whole_dev);
 778         if (ret < 0)
 779                 printf("Couldn't find partition %s %s\n",
 780                        dev_iface, dev_part_str);
 781         return ret;
 782 }
 783
 784 void part_set_generic_name(const struct blk_desc *dev_desc,
 785         int part_num, char *name)
 786 {
 787         char *devtype;
 788
 789         switch (dev_desc->uclass_id) {
 790         case UCLASS_IDE:
 791         case UCLASS_AHCI:
 792                 devtype = "hd";
 793                 break;
 794         case UCLASS_SCSI:
 795                 devtype = "sd";
 796                 break;
 797         case UCLASS_USB:
 798                 devtype = "usbd";
 799                 break;
 800         case UCLASS_MMC:
 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 }
 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 }