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