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 (!dev_part_str || !strlen(dev_part_str) ||
 512             !strcmp(dev_part_str, "-"))
 513                 dev_part_str = env_get("bootdevice");
 514
 515         /* If still no dev_part_str, it's an error */
 516         if (!dev_part_str) {
 517                 printf("** No device specified **\n");
 518                 ret = -ENODEV;
 519                 goto cleanup;
 520         }
 521
 522         /* Separate device and partition ID specification */
 523         part_str = strchr(dev_part_str, ':');
 524         if (part_str) {
 525                 dup_str = strdup(dev_part_str);
 526                 dup_str[part_str - dev_part_str] = 0;
 527                 dev_str = dup_str;
 528                 part_str++;
 529         } else {
 530                 dev_str = dev_part_str;
 531         }
 532
 533         /* Look up the device */
 534         dev = blk_get_device_by_str(ifname, dev_str, dev_desc);
 535         if (dev < 0) {
 536                 printf("** Bad device specification %s %s **\n",
 537                        ifname, dev_str);
 538                 ret = dev;
 539                 goto cleanup;
 540         }
 541
 542         /* Convert partition ID string to number */
 543         if (!part_str || !*part_str) {
 544                 part = PART_UNSPECIFIED;
 545         } else if (!strcmp(part_str, "auto")) {
 546                 part = PART_AUTO;
 547         } else {
 548                 /* Something specified -> use exactly that */
 549                 part = (int)hextoul(part_str, &ep);
 550                 /*
 551                  * Less than whole string converted,
 552                  * or request for whole device, but caller requires partition.
 553                  */
 554                 if (*ep || (part == 0 && !allow_whole_dev)) {
 555                         printf("** Bad partition specification %s %s **\n",
 556                             ifname, dev_part_str);
 557                         ret = -ENOENT;
 558                         goto cleanup;
 559                 }
 560         }
 561
 562         /*
 563          * No partition table on device,
 564          * or user requested partition 0 (entire device).
 565          */
 566         if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) ||
 567             (part == 0)) {
 568                 if (!(*dev_desc)->lba) {
 569                         printf("** Bad device size - %s %s **\n", ifname,
 570                                dev_str);
 571                         ret = -EINVAL;
 572                         goto cleanup;
 573                 }
 574
 575                 /*
 576                  * If user specified a partition ID other than 0,
 577                  * or the calling command only accepts partitions,
 578                  * it's an error.
 579                  */
 580                 if ((part > 0) || (!allow_whole_dev)) {
 581                         printf("** No partition table - %s %s **\n", ifname,
 582                                dev_str);
 583                         ret = -EPROTONOSUPPORT;
 584                         goto cleanup;
 585                 }
 586
 587                 (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
 588
 589                 part_get_info_whole_disk(*dev_desc, info);
 590
 591                 ret = 0;
 592                 goto cleanup;
 593         }
 594
 595         /*
 596          * Now there's known to be a partition table,
 597          * not specifying a partition means to pick partition 1.
 598          */
 599         if (part == PART_UNSPECIFIED)
 600                 part = 1;
 601
 602         /*
 603          * If user didn't specify a partition number, or did specify something
 604          * other than "auto", use that partition number directly.
 605          */
 606         if (part != PART_AUTO) {
 607                 ret = part_get_info(*dev_desc, part, info);
 608                 if (ret) {
 609                         printf("** Invalid partition %d **\n", part);
 610                         goto cleanup;
 611                 }
 612         } else {
 613                 /*
 614                  * Find the first bootable partition.
 615                  * If none are bootable, fall back to the first valid partition.
 616                  */
 617                 part = 0;
 618                 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
 619                         ret = part_get_info(*dev_desc, p, info);
 620                         if (ret)
 621                                 continue;
 622
 623                         /*
 624                          * First valid partition, or new better partition?
 625                          * If so, save partition ID.
 626                          */
 627                         if (!part || info->bootable)
 628                                 part = p;
 629
 630                         /* Best possible partition? Stop searching. */
 631                         if (info->bootable)
 632                                 break;
 633
 634                         /*
 635                          * We now need to search further for best possible.
 636                          * If we what we just queried was the best so far,
 637                          * save the info since we over-write it next loop.
 638                          */
 639                         if (part == p)
 640                                 tmpinfo = *info;
 641                 }
 642                 /* If we found any acceptable partition */
 643                 if (part) {
 644                         /*
 645                          * If we searched all possible partition IDs,
 646                          * return the first valid partition we found.
 647                          */
 648                         if (p == MAX_SEARCH_PARTITIONS + 1)
 649                                 *info = tmpinfo;
 650                 } else {
 651                         printf("** No valid partitions found **\n");
 652                         goto cleanup;
 653                 }
 654         }
 655         if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) {
 656                 printf("** Invalid partition type \"%.32s\""
 657                         " (expect \"" BOOT_PART_TYPE "\")\n",
 658                         info->type);
 659                 ret  = -EINVAL;
 660                 goto cleanup;
 661         }
 662
 663         (*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);
 664
 665         ret = part;
 666         goto cleanup;
 667
 668 cleanup:
 669         free(dup_str);
 670         return ret;
 671 }
 672
 673 int part_get_info_by_name_type(struct blk_desc *dev_desc, const char *name,
 674                                struct disk_partition *info, int part_type)
 675 {
 676         struct part_driver *part_drv;
 677         int ret;
 678         int i;
 679
 680         part_drv = part_driver_lookup_type(dev_desc);
 681         if (!part_drv)
 682                 return -1;
 683
 684         if (!part_drv->get_info) {
 685                 log_debug("## Driver %s does not have the get_info() method\n",
 686                           part_drv->name);
 687                 return -ENOSYS;
 688         }
 689
 690         for (i = 1; i < part_drv->max_entries; i++) {
 691                 ret = part_drv->get_info(dev_desc, i, info);
 692                 if (ret != 0) {
 693                         /* no more entries in table */
 694                         break;
 695                 }
 696                 if (strcmp(name, (const char *)info->name) == 0) {
 697                         /* matched */
 698                         return i;
 699                 }
 700         }
 701
 702         return -ENOENT;
 703 }
 704
 705 int part_get_info_by_name(struct blk_desc *dev_desc, const char *name,
 706                           struct disk_partition *info)
 707 {
 708         return part_get_info_by_name_type(dev_desc, name, info, PART_TYPE_ALL);
 709 }
 710
 711 /**
 712  * Get partition info from device number and partition name.
 713  *
 714  * Parse a device number and partition name string in the form of
 715  * "devicenum.hwpartnum#partition_name", for example "0.1#misc". devicenum and
 716  * hwpartnum are both optional, defaulting to 0. If the partition is found,
 717  * sets dev_desc and part_info accordingly with the information of the
 718  * partition with the given partition_name.
 719  *
 720  * @param[in] dev_iface Device interface
 721  * @param[in] dev_part_str Input string argument, like "0.1#misc"
 722  * @param[out] dev_desc Place to store the device description pointer
 723  * @param[out] part_info Place to store the partition information
 724  * Return: 0 on success, or a negative on error
 725  */
 726 static int part_get_info_by_dev_and_name(const char *dev_iface,
 727                                          const char *dev_part_str,
 728                                          struct blk_desc **dev_desc,
 729                                          struct disk_partition *part_info)
 730 {
 731         char *dup_str = NULL;
 732         const char *dev_str, *part_str;
 733         int ret;
 734
 735         /* Separate device and partition name specification */
 736         if (dev_part_str)
 737                 part_str = strchr(dev_part_str, '#');
 738         else
 739                 part_str = NULL;
 740
 741         if (part_str) {
 742                 dup_str = strdup(dev_part_str);
 743                 dup_str[part_str - dev_part_str] = 0;
 744                 dev_str = dup_str;
 745                 part_str++;
 746         } else {
 747                 return -EINVAL;
 748         }
 749
 750         ret = blk_get_device_by_str(dev_iface, dev_str, dev_desc);
 751         if (ret < 0)
 752                 goto cleanup;
 753
 754         ret = part_get_info_by_name(*dev_desc, part_str, part_info);
 755         if (ret < 0)
 756                 printf("Could not find \"%s\" partition\n", part_str);
 757
 758 cleanup:
 759         free(dup_str);
 760         return ret;
 761 }
 762
 763 int part_get_info_by_dev_and_name_or_num(const char *dev_iface,
 764                                          const char *dev_part_str,
 765                                          struct blk_desc **dev_desc,
 766                                          struct disk_partition *part_info,
 767                                          int allow_whole_dev)
 768 {
 769         int ret;
 770
 771         /* Split the part_name if passed as "$dev_num#part_name". */
 772         ret = part_get_info_by_dev_and_name(dev_iface, dev_part_str,
 773                                             dev_desc, part_info);
 774         if (ret >= 0)
 775                 return ret;
 776         /*
 777          * Couldn't lookup by name, try looking up the partition description
 778          * directly.
 779          */
 780         ret = blk_get_device_part_str(dev_iface, dev_part_str,
 781                                       dev_desc, part_info, allow_whole_dev);
 782         if (ret < 0)
 783                 printf("Couldn't find partition %s %s\n",
 784                        dev_iface, dev_part_str);
 785         return ret;
 786 }
 787
 788 void part_set_generic_name(const struct blk_desc *dev_desc,
 789         int part_num, char *name)
 790 {
 791         char *devtype;
 792
 793         switch (dev_desc->uclass_id) {
 794         case UCLASS_IDE:
 795         case UCLASS_AHCI:
 796                 devtype = "hd";
 797                 break;
 798         case UCLASS_SCSI:
 799                 devtype = "sd";
 800                 break;
 801         case UCLASS_USB:
 802                 devtype = "usbd";
 803                 break;
 804         case UCLASS_MMC:
 805                 devtype = "mmcsd";
 806                 break;
 807         default:
 808                 devtype = "xx";
 809                 break;
 810         }
 811
 812         sprintf(name, "%s%c%d", devtype, 'a' + dev_desc->devnum, part_num);
 813 }
 814
 815 int part_get_bootable(struct blk_desc *desc)
 816 {
 817         struct disk_partition info;
 818         int p;
 819
 820         for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
 821                 int ret;
 822
 823                 ret = part_get_info(desc, p, &info);
 824                 if (!ret && info.bootable)
 825                         return p;
 826         }
 827
 828         return 0;
 829 }