disk/part.c

   1 /*
   2  * (C) Copyright 2001
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 #include <common.h>
  25 #include <command.h>
  26 #include <ide.h>
  27 #include <malloc.h>
  28 #include <part.h>
  29
  30 #undef  PART_DEBUG
  31
  32 #ifdef  PART_DEBUG
  33 #define PRINTF(fmt,args...)     printf (fmt ,##args)
  34 #else
  35 #define PRINTF(fmt,args...)
  36 #endif
  37
  38 #if (defined(CONFIG_CMD_IDE) || \
  39      defined(CONFIG_CMD_SATA) || \
  40      defined(CONFIG_CMD_SCSI) || \
  41      defined(CONFIG_CMD_USB) || \
  42      defined(CONFIG_MMC) || \
  43      defined(CONFIG_SYSTEMACE) )
  44
  45 struct block_drvr {
  46         char *name;
  47         block_dev_desc_t* (*get_dev)(int dev);
  48 };
  49
  50 static const struct block_drvr block_drvr[] = {
  51 #if defined(CONFIG_CMD_IDE)
  52         { .name = "ide", .get_dev = ide_get_dev, },
  53 #endif
  54 #if defined(CONFIG_CMD_SATA)
  55         {.name = "sata", .get_dev = sata_get_dev, },
  56 #endif
  57 #if defined(CONFIG_CMD_SCSI)
  58         { .name = "scsi", .get_dev = scsi_get_dev, },
  59 #endif
  60 #if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE)
  61         { .name = "usb", .get_dev = usb_stor_get_dev, },
  62 #endif
  63 #if defined(CONFIG_MMC)
  64         { .name = "mmc", .get_dev = mmc_get_dev, },
  65 #endif
  66 #if defined(CONFIG_SYSTEMACE)
  67         { .name = "ace", .get_dev = systemace_get_dev, },
  68 #endif
  69         { },
  70 };
  71
  72 DECLARE_GLOBAL_DATA_PTR;
  73
  74 block_dev_desc_t *get_dev(const char *ifname, int dev)
  75 {
  76         const struct block_drvr *drvr = block_drvr;
  77         block_dev_desc_t* (*reloc_get_dev)(int dev);
  78         char *name;
  79
  80         if (!ifname)
  81                 return NULL;
  82
  83         name = drvr->name;
  84 #ifdef CONFIG_NEEDS_MANUAL_RELOC
  85         name += gd->reloc_off;
  86 #endif
  87         while (drvr->name) {
  88                 name = drvr->name;
  89                 reloc_get_dev = drvr->get_dev;
  90 #ifdef CONFIG_NEEDS_MANUAL_RELOC
  91                 name += gd->reloc_off;
  92                 reloc_get_dev += gd->reloc_off;
  93 #endif
  94                 if (strncmp(ifname, name, strlen(name)) == 0)
  95                         return reloc_get_dev(dev);
  96                 drvr++;
  97         }
  98         return NULL;
  99 }
 100 #else
 101 block_dev_desc_t *get_dev(const char *ifname, int dev)
 102 {
 103         return NULL;
 104 }
 105 #endif
 106
 107 #if (defined(CONFIG_CMD_IDE) || \
 108      defined(CONFIG_CMD_SATA) || \
 109      defined(CONFIG_CMD_SCSI) || \
 110      defined(CONFIG_CMD_USB) || \
 111      defined(CONFIG_MMC) || \
 112      defined(CONFIG_SYSTEMACE) )
 113
 114 /* ------------------------------------------------------------------------- */
 115 /*
 116  * reports device info to the user
 117  */
 118
 119 #ifdef CONFIG_LBA48
 120 typedef uint64_t lba512_t;
 121 #else
 122 typedef lbaint_t lba512_t;
 123 #endif
 124
 125 /*
 126  * Overflowless variant of (block_count * mul_by / div_by)
 127  * when div_by > mul_by
 128  */
 129 static lba512_t lba512_muldiv (lba512_t block_count, lba512_t mul_by, lba512_t div_by)
 130 {
 131         lba512_t bc_quot, bc_rem;
 132
 133         /* x * m / d == x / d * m + (x % d) * m / d */
 134         bc_quot = block_count / div_by;
 135         bc_rem  = block_count - div_by * bc_quot;
 136         return bc_quot * mul_by + (bc_rem * mul_by) / div_by;
 137 }
 138
 139 void dev_print (block_dev_desc_t *dev_desc)
 140 {
 141         lba512_t lba512; /* number of blocks if 512bytes block size */
 142
 143         if (dev_desc->type == DEV_TYPE_UNKNOWN) {
 144                 puts ("not available\n");
 145                 return;
 146         }
 147
 148         switch (dev_desc->if_type) {
 149         case IF_TYPE_SCSI:
 150                 printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n",
 151                         dev_desc->target,dev_desc->lun,
 152                         dev_desc->vendor,
 153                         dev_desc->product,
 154                         dev_desc->revision);
 155                 break;
 156         case IF_TYPE_ATAPI:
 157         case IF_TYPE_IDE:
 158         case IF_TYPE_SATA:
 159                 printf ("Model: %s Firm: %s Ser#: %s\n",
 160                         dev_desc->vendor,
 161                         dev_desc->revision,
 162                         dev_desc->product);
 163                 break;
 164         case IF_TYPE_SD:
 165         case IF_TYPE_MMC:
 166         case IF_TYPE_USB:
 167                 printf ("Vendor: %s Rev: %s Prod: %s\n",
 168                         dev_desc->vendor,
 169                         dev_desc->revision,
 170                         dev_desc->product);
 171                 break;
 172         case IF_TYPE_DOC:
 173                 puts("device type DOC\n");
 174                 return;
 175         case IF_TYPE_UNKNOWN:
 176                 puts("device type unknown\n");
 177                 return;
 178         default:
 179                 printf("Unhandled device type: %i\n", dev_desc->if_type);
 180                 return;
 181         }
 182         puts ("            Type: ");
 183         if (dev_desc->removable)
 184                 puts ("Removable ");
 185         switch (dev_desc->type & 0x1F) {
 186         case DEV_TYPE_HARDDISK:
 187                 puts ("Hard Disk");
 188                 break;
 189         case DEV_TYPE_CDROM:
 190                 puts ("CD ROM");
 191                 break;
 192         case DEV_TYPE_OPDISK:
 193                 puts ("Optical Device");
 194                 break;
 195         case DEV_TYPE_TAPE:
 196                 puts ("Tape");
 197                 break;
 198         default:
 199                 printf ("# %02X #", dev_desc->type & 0x1F);
 200                 break;
 201         }
 202         puts ("\n");
 203         if ((dev_desc->lba * dev_desc->blksz)>0L) {
 204                 ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;
 205                 lbaint_t lba;
 206
 207                 lba = dev_desc->lba;
 208
 209                 lba512 = (lba * (dev_desc->blksz/512));
 210                 /* round to 1 digit */
 211                 mb = lba512_muldiv(lba512, 10, 2048);   /* 2048 = (1024 * 1024) / 512 MB */
 212
 213                 mb_quot = mb / 10;
 214                 mb_rem  = mb - (10 * mb_quot);
 215
 216                 gb = mb / 1024;
 217                 gb_quot = gb / 10;
 218                 gb_rem  = gb - (10 * gb_quot);
 219 #ifdef CONFIG_LBA48
 220                 if (dev_desc->lba48)
 221                         printf ("            Supports 48-bit addressing\n");
 222 #endif
 223 #if defined(CONFIG_SYS_64BIT_LBA)
 224                 printf ("            Capacity: %ld.%ld MB = %ld.%ld GB (%Ld x %ld)\n",
 225                         mb_quot, mb_rem,
 226                         gb_quot, gb_rem,
 227                         lba,
 228                         dev_desc->blksz);
 229 #else
 230                 printf ("            Capacity: %ld.%ld MB = %ld.%ld GB (%ld x %ld)\n",
 231                         mb_quot, mb_rem,
 232                         gb_quot, gb_rem,
 233                         (ulong)lba,
 234                         dev_desc->blksz);
 235 #endif
 236         } else {
 237                 puts ("            Capacity: not available\n");
 238         }
 239 }
 240 #endif
 241
 242 #if (defined(CONFIG_CMD_IDE) || \
 243      defined(CONFIG_CMD_SATA) || \
 244      defined(CONFIG_CMD_SCSI) || \
 245      defined(CONFIG_CMD_USB) || \
 246      defined(CONFIG_MMC)                || \
 247      defined(CONFIG_SYSTEMACE) )
 248
 249 #if defined(CONFIG_MAC_PARTITION) || \
 250     defined(CONFIG_DOS_PARTITION) || \
 251     defined(CONFIG_ISO_PARTITION) || \
 252     defined(CONFIG_AMIGA_PARTITION) || \
 253     defined(CONFIG_EFI_PARTITION)
 254
 255 void init_part (block_dev_desc_t * dev_desc)
 256 {
 257 #ifdef CONFIG_ISO_PARTITION
 258         if (test_part_iso(dev_desc) == 0) {
 259                 dev_desc->part_type = PART_TYPE_ISO;
 260                 return;
 261         }
 262 #endif
 263
 264 #ifdef CONFIG_MAC_PARTITION
 265         if (test_part_mac(dev_desc) == 0) {
 266                 dev_desc->part_type = PART_TYPE_MAC;
 267                 return;
 268         }
 269 #endif
 270
 271 /* must be placed before DOS partition detection */
 272 #ifdef CONFIG_EFI_PARTITION
 273         if (test_part_efi(dev_desc) == 0) {
 274                 dev_desc->part_type = PART_TYPE_EFI;
 275                 return;
 276         }
 277 #endif
 278
 279 #ifdef CONFIG_DOS_PARTITION
 280         if (test_part_dos(dev_desc) == 0) {
 281                 dev_desc->part_type = PART_TYPE_DOS;
 282                 return;
 283         }
 284 #endif
 285
 286 #ifdef CONFIG_AMIGA_PARTITION
 287         if (test_part_amiga(dev_desc) == 0) {
 288             dev_desc->part_type = PART_TYPE_AMIGA;
 289             return;
 290         }
 291 #endif
 292         dev_desc->part_type = PART_TYPE_UNKNOWN;
 293 }
 294
 295
 296 static void print_part_header (const char *type, block_dev_desc_t * dev_desc)
 297 {
 298         puts ("\nPartition Map for ");
 299         switch (dev_desc->if_type) {
 300         case IF_TYPE_IDE:
 301                 puts ("IDE");
 302                 break;
 303         case IF_TYPE_SATA:
 304                 puts ("SATA");
 305                 break;
 306         case IF_TYPE_SCSI:
 307                 puts ("SCSI");
 308                 break;
 309         case IF_TYPE_ATAPI:
 310                 puts ("ATAPI");
 311                 break;
 312         case IF_TYPE_USB:
 313                 puts ("USB");
 314                 break;
 315         case IF_TYPE_DOC:
 316                 puts ("DOC");
 317                 break;
 318         case IF_TYPE_MMC:
 319                 puts ("MMC");
 320                 break;
 321         default:
 322                 puts ("UNKNOWN");
 323                 break;
 324         }
 325         printf (" device %d  --   Partition Type: %s\n\n",
 326                         dev_desc->dev, type);
 327 }
 328
 329 void print_part (block_dev_desc_t * dev_desc)
 330 {
 331
 332                 switch (dev_desc->part_type) {
 333 #ifdef CONFIG_MAC_PARTITION
 334         case PART_TYPE_MAC:
 335                 PRINTF ("## Testing for valid MAC partition ##\n");
 336                 print_part_header ("MAC", dev_desc);
 337                 print_part_mac (dev_desc);
 338                 return;
 339 #endif
 340 #ifdef CONFIG_DOS_PARTITION
 341         case PART_TYPE_DOS:
 342                 PRINTF ("## Testing for valid DOS partition ##\n");
 343                 print_part_header ("DOS", dev_desc);
 344                 print_part_dos (dev_desc);
 345                 return;
 346 #endif
 347
 348 #ifdef CONFIG_ISO_PARTITION
 349         case PART_TYPE_ISO:
 350                 PRINTF ("## Testing for valid ISO Boot partition ##\n");
 351                 print_part_header ("ISO", dev_desc);
 352                 print_part_iso (dev_desc);
 353                 return;
 354 #endif
 355
 356 #ifdef CONFIG_AMIGA_PARTITION
 357         case PART_TYPE_AMIGA:
 358             PRINTF ("## Testing for a valid Amiga partition ##\n");
 359             print_part_header ("AMIGA", dev_desc);
 360             print_part_amiga (dev_desc);
 361             return;
 362 #endif
 363
 364 #ifdef CONFIG_EFI_PARTITION
 365         case PART_TYPE_EFI:
 366                 PRINTF ("## Testing for valid EFI partition ##\n");
 367                 print_part_header ("EFI", dev_desc);
 368                 print_part_efi (dev_desc);
 369                 return;
 370 #endif
 371         }
 372         puts ("## Unknown partition table\n");
 373 }
 374
 375
 376 #else   /* neither MAC nor DOS nor ISO nor AMIGA nor EFI partition configured */
 377 # error neither CONFIG_MAC_PARTITION nor CONFIG_DOS_PARTITION
 378 # error nor CONFIG_ISO_PARTITION nor CONFIG_AMIGA_PARTITION
 379 # error nor CONFIG_EFI_PARTITION configured!
 380 #endif
 381
 382 #endif
 383
 384 int get_partition_info(block_dev_desc_t *dev_desc, int part
 385                                         , disk_partition_t *info)
 386 {
 387 #if defined(CONFIG_CMD_IDE) || \
 388         defined(CONFIG_CMD_SATA) || \
 389         defined(CONFIG_CMD_SCSI) || \
 390         defined(CONFIG_CMD_USB) || \
 391         defined(CONFIG_MMC) || \
 392         defined(CONFIG_SYSTEMACE)
 393
 394 #ifdef CONFIG_PARTITION_UUIDS
 395         /* The common case is no UUID support */
 396         info->uuid[0] = 0;
 397 #endif
 398
 399         switch (dev_desc->part_type) {
 400 #ifdef CONFIG_MAC_PARTITION
 401         case PART_TYPE_MAC:
 402                 if (get_partition_info_mac(dev_desc, part, info) == 0) {
 403                         PRINTF("## Valid MAC partition found ##\n");
 404                         return 0;
 405                 }
 406                 break;
 407 #endif
 408
 409 #ifdef CONFIG_DOS_PARTITION
 410         case PART_TYPE_DOS:
 411                 if (get_partition_info_dos(dev_desc, part, info) == 0) {
 412                         PRINTF("## Valid DOS partition found ##\n");
 413                         return 0;
 414                 }
 415                 break;
 416 #endif
 417
 418 #ifdef CONFIG_ISO_PARTITION
 419         case PART_TYPE_ISO:
 420                 if (get_partition_info_iso(dev_desc, part, info) == 0) {
 421                         PRINTF("## Valid ISO boot partition found ##\n");
 422                         return 0;
 423                 }
 424                 break;
 425 #endif
 426
 427 #ifdef CONFIG_AMIGA_PARTITION
 428         case PART_TYPE_AMIGA:
 429                 if (get_partition_info_amiga(dev_desc, part, info) == 0) {
 430                         PRINTF("## Valid Amiga partition found ##\n");
 431                         return 0;
 432                 }
 433                 break;
 434 #endif
 435
 436 #ifdef CONFIG_EFI_PARTITION
 437         case PART_TYPE_EFI:
 438                 if (get_partition_info_efi(dev_desc, part, info) == 0) {
 439                         PRINTF("## Valid EFI partition found ##\n");
 440                         return 0;
 441                 }
 442                 break;
 443 #endif
 444         default:
 445                 break;
 446         }
 447 #endif
 448
 449         return -1;
 450 }
 451
 452 int get_device(const char *ifname, const char *dev_str,
 453                block_dev_desc_t **dev_desc)
 454 {
 455         char *ep;
 456         int dev;
 457
 458         dev = simple_strtoul(dev_str, &ep, 16);
 459         if (*ep) {
 460                 printf("** Bad device specification %s %s **\n",
 461                        ifname, dev_str);
 462                 return -1;
 463         }
 464
 465         *dev_desc = get_dev(ifname, dev);
 466         if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) {
 467                 printf("** Bad device %s %s **\n", ifname, dev_str);
 468                 return -1;
 469         }
 470
 471         return dev;
 472 }
 473
 474 #define PART_UNSPECIFIED -2
 475 #define PART_AUTO -1
 476 #define MAX_SEARCH_PARTITIONS 16
 477 int get_device_and_partition(const char *ifname, const char *dev_part_str,
 478                              block_dev_desc_t **dev_desc,
 479                              disk_partition_t *info, int allow_whole_dev)
 480 {
 481         int ret = -1;
 482         const char *part_str;
 483         char *dup_str = NULL;
 484         const char *dev_str;
 485         int dev;
 486         char *ep;
 487         int p;
 488         int part;
 489         disk_partition_t tmpinfo;
 490
 491         /* If no dev_part_str, use bootdevice environment variable */
 492         if (!dev_part_str || !strlen(dev_part_str) ||
 493             !strcmp(dev_part_str, "-"))
 494                 dev_part_str = getenv("bootdevice");
 495
 496         /* If still no dev_part_str, it's an error */
 497         if (!dev_part_str) {
 498                 printf("** No device specified **\n");
 499                 goto cleanup;
 500         }
 501
 502         /* Separate device and partition ID specification */
 503         part_str = strchr(dev_part_str, ':');
 504         if (part_str) {
 505                 dup_str = strdup(dev_part_str);
 506                 dup_str[part_str - dev_part_str] = 0;
 507                 dev_str = dup_str;
 508                 part_str++;
 509         } else {
 510                 dev_str = dev_part_str;
 511         }
 512
 513         /* Look up the device */
 514         dev = get_device(ifname, dev_str, dev_desc);
 515         if (dev < 0)
 516                 goto cleanup;
 517
 518         /* Convert partition ID string to number */
 519         if (!part_str || !*part_str) {
 520                 part = PART_UNSPECIFIED;
 521         } else if (!strcmp(part_str, "auto")) {
 522                 part = PART_AUTO;
 523         } else {
 524                 /* Something specified -> use exactly that */
 525                 part = (int)simple_strtoul(part_str, &ep, 16);
 526                 /*
 527                  * Less than whole string converted,
 528                  * or request for whole device, but caller requires partition.
 529                  */
 530                 if (*ep || (part == 0 && !allow_whole_dev)) {
 531                         printf("** Bad partition specification %s %s **\n",
 532                             ifname, dev_part_str);
 533                         goto cleanup;
 534                 }
 535         }
 536
 537         /*
 538          * No partition table on device,
 539          * or user requested partition 0 (entire device).
 540          */
 541         if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) ||
 542             (part == 0)) {
 543                 if (!(*dev_desc)->lba) {
 544                         printf("** Bad device size - %s %s **\n", ifname,
 545                                dev_str);
 546                         goto cleanup;
 547                 }
 548
 549                 /*
 550                  * If user specified a partition ID other than 0,
 551                  * or the calling command only accepts partitions,
 552                  * it's an error.
 553                  */
 554                 if ((part > 0) || (!allow_whole_dev)) {
 555                         printf("** No partition table - %s %s **\n", ifname,
 556                                dev_str);
 557                         goto cleanup;
 558                 }
 559
 560                 info->start = 0;
 561                 info->size = (*dev_desc)->lba;
 562                 info->blksz = (*dev_desc)->blksz;
 563                 info->bootable = 0;
 564 #ifdef CONFIG_PARTITION_UUIDS
 565                 info->uuid[0] = 0;
 566 #endif
 567
 568                 ret = 0;
 569                 goto cleanup;
 570         }
 571
 572         /*
 573          * Now there's known to be a partition table,
 574          * not specifying a partition means to pick partition 1.
 575          */
 576         if (part == PART_UNSPECIFIED)
 577                 part = 1;
 578
 579         /*
 580          * If user didn't specify a partition number, or did specify something
 581          * other than "auto", use that partition number directly.
 582          */
 583         if (part != PART_AUTO) {
 584                 ret = get_partition_info(*dev_desc, part, info);
 585                 if (ret) {
 586                         printf("** Invalid partition %d **\n", part);
 587                         goto cleanup;
 588                 }
 589         } else {
 590                 /*
 591                  * Find the first bootable partition.
 592                  * If none are bootable, fall back to the first valid partition.
 593                  */
 594                 part = 0;
 595                 for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
 596                         ret = get_partition_info(*dev_desc, p, info);
 597                         if (ret)
 598                                 continue;
 599
 600                         /*
 601                          * First valid partition, or new better partition?
 602                          * If so, save partition ID.
 603                          */
 604                         if (!part || info->bootable)
 605                                 part = p;
 606
 607                         /* Best possible partition? Stop searching. */
 608                         if (info->bootable)
 609                                 break;
 610
 611                         /*
 612                          * We now need to search further for best possible.
 613                          * If we what we just queried was the best so far,
 614                          * save the info since we over-write it next loop.
 615                          */
 616                         if (part == p)
 617                                 tmpinfo = *info;
 618                 }
 619                 /* If we found any acceptable partition */
 620                 if (part) {
 621                         /*
 622                          * If we searched all possible partition IDs,
 623                          * return the first valid partition we found.
 624                          */
 625                         if (p == MAX_SEARCH_PARTITIONS + 1)
 626                                 *info = tmpinfo;
 627                         ret = 0;
 628                 } else {
 629                         printf("** No valid partitions found **\n");
 630                         goto cleanup;
 631                 }
 632         }
 633         if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) {
 634                 printf("** Invalid partition type \"%.32s\""
 635                         " (expect \"" BOOT_PART_TYPE "\")\n",
 636                         info->type);
 637                 ret  = -1;
 638                 goto cleanup;
 639         }
 640
 641         ret = part;
 642         goto cleanup;
 643
 644 cleanup:
 645         free(dup_str);
 646         return ret;
 647 }