part.c 14.2 KB
Newer Older
wdenk's avatar
wdenk committed
1 2 3 4
/*
 * (C) Copyright 2001
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
5
 * SPDX-License-Identifier:	GPL-2.0+
wdenk's avatar
wdenk committed
6 7 8 9
 */

#include <common.h>
#include <command.h>
10
#include <errno.h>
wdenk's avatar
wdenk committed
11
#include <ide.h>
12
#include <malloc.h>
13
#include <part.h>
Hans de Goede's avatar
Hans de Goede committed
14
#include <ubifs_uboot.h>
wdenk's avatar
wdenk committed
15 16 17 18 19 20 21 22 23

#undef	PART_DEBUG

#ifdef	PART_DEBUG
#define	PRINTF(fmt,args...)	printf (fmt ,##args)
#else
#define PRINTF(fmt,args...)
#endif

24 25
DECLARE_GLOBAL_DATA_PTR;

26
#ifdef HAVE_BLOCK_DEVICE
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
static struct part_driver *part_driver_lookup_type(int part_type)
{
	struct part_driver *drv =
		ll_entry_start(struct part_driver, part_driver);
	const int n_ents = ll_entry_count(struct part_driver, part_driver);
	struct part_driver *entry;

	for (entry = drv; entry != drv + n_ents; entry++) {
		if (part_type == entry->part_type)
			return entry;
	}

	/* Not found */
	return NULL;
}

43
static struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
44
{
45 46
	struct blk_desc *dev_desc;
	int ret;
47

48 49 50 51
	dev_desc = blk_get_devnum_by_typename(ifname, dev);
	if (!dev_desc) {
		debug("%s: No device for iface '%s', dev %d\n", __func__,
		      ifname, dev);
52
		return NULL;
53
	}
54 55 56 57 58 59 60 61
	ret = blk_dselect_hwpart(dev_desc, hwpart);
	if (ret) {
		debug("%s: Failed to select h/w partition: err-%d\n", __func__,
		      ret);
		return NULL;
	}

	return dev_desc;
62
}
63

64
struct blk_desc *blk_get_dev(const char *ifname, int dev)
65
{
66
	return get_dev_hwpart(ifname, dev, 0);
67
}
68
#else
69
struct blk_desc *get_dev_hwpart(const char *ifname, int dev, int hwpart)
70 71 72 73
{
	return NULL;
}

74
struct blk_desc *blk_get_dev(const char *ifname, int dev)
75 76 77 78 79
{
	return NULL;
}
#endif

80
#ifdef HAVE_BLOCK_DEVICE
wdenk's avatar
wdenk committed
81 82 83 84 85

/* ------------------------------------------------------------------------- */
/*
 * reports device info to the user
 */
86

87
#ifdef CONFIG_LBA48
88
typedef uint64_t lba512_t;
89
#else
90
typedef lbaint_t lba512_t;
91
#endif
wdenk's avatar
wdenk committed
92

93 94 95 96
/*
 * Overflowless variant of (block_count * mul_by / div_by)
 * when div_by > mul_by
 */
Pavel Machek's avatar
Pavel Machek committed
97
static lba512_t lba512_muldiv(lba512_t block_count, lba512_t mul_by, lba512_t div_by)
98 99 100 101 102 103 104 105 106
{
	lba512_t bc_quot, bc_rem;

	/* x * m / d == x / d * m + (x % d) * m / d */
	bc_quot = block_count / div_by;
	bc_rem  = block_count - div_by * bc_quot;
	return bc_quot * mul_by + (bc_rem * mul_by) / div_by;
}

107
void dev_print (struct blk_desc *dev_desc)
108 109 110
{
	lba512_t lba512; /* number of blocks if 512bytes block size */

111 112 113 114 115
	if (dev_desc->type == DEV_TYPE_UNKNOWN) {
		puts ("not available\n");
		return;
	}

116
	switch (dev_desc->if_type) {
117 118 119
	case IF_TYPE_SCSI:
		printf ("(%d:%d) Vendor: %s Prod.: %s Rev: %s\n",
			dev_desc->target,dev_desc->lun,
wdenk's avatar
wdenk committed
120
			dev_desc->vendor,
121 122 123
			dev_desc->product,
			dev_desc->revision);
		break;
124
	case IF_TYPE_ATAPI:
125 126
	case IF_TYPE_IDE:
	case IF_TYPE_SATA:
127 128 129 130
		printf ("Model: %s Firm: %s Ser#: %s\n",
			dev_desc->vendor,
			dev_desc->revision,
			dev_desc->product);
131
		break;
132 133
	case IF_TYPE_SD:
	case IF_TYPE_MMC:
134 135 136 137 138 139
	case IF_TYPE_USB:
		printf ("Vendor: %s Rev: %s Prod: %s\n",
			dev_desc->vendor,
			dev_desc->revision,
			dev_desc->product);
		break;
140 141 142
	case IF_TYPE_DOC:
		puts("device type DOC\n");
		return;
143
	case IF_TYPE_UNKNOWN:
144 145
		puts("device type unknown\n");
		return;
146
	default:
147
		printf("Unhandled device type: %i\n", dev_desc->if_type);
148
		return;
wdenk's avatar
wdenk committed
149 150 151 152 153
	}
	puts ("            Type: ");
	if (dev_desc->removable)
		puts ("Removable ");
	switch (dev_desc->type & 0x1F) {
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
	case DEV_TYPE_HARDDISK:
		puts ("Hard Disk");
		break;
	case DEV_TYPE_CDROM:
		puts ("CD ROM");
		break;
	case DEV_TYPE_OPDISK:
		puts ("Optical Device");
		break;
	case DEV_TYPE_TAPE:
		puts ("Tape");
		break;
	default:
		printf ("# %02X #", dev_desc->type & 0x1F);
		break;
wdenk's avatar
wdenk committed
169 170
	}
	puts ("\n");
171
	if (dev_desc->lba > 0L && dev_desc->blksz > 0L) {
wdenk's avatar
wdenk committed
172
		ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;
173
		lbaint_t lba;
wdenk's avatar
wdenk committed
174 175

		lba = dev_desc->lba;
wdenk's avatar
wdenk committed
176

177
		lba512 = (lba * (dev_desc->blksz/512));
wdenk's avatar
wdenk committed
178
		/* round to 1 digit */
Pavel Machek's avatar
Pavel Machek committed
179 180
		/* 2048 = (1024 * 1024) / 512 MB */
		mb = lba512_muldiv(lba512, 10, 2048);
181

wdenk's avatar
wdenk committed
182 183 184 185 186 187
		mb_quot	= mb / 10;
		mb_rem	= mb - (10 * mb_quot);

		gb = mb / 1024;
		gb_quot	= gb / 10;
		gb_rem	= gb - (10 * gb_quot);
188
#ifdef CONFIG_LBA48
wdenk's avatar
wdenk committed
189
		if (dev_desc->lba48)
190 191
			printf ("            Supports 48-bit addressing\n");
#endif
192
#if defined(CONFIG_SYS_64BIT_LBA)
193
		printf ("            Capacity: %ld.%ld MB = %ld.%ld GB (%Ld x %ld)\n",
194 195 196 197 198
			mb_quot, mb_rem,
			gb_quot, gb_rem,
			lba,
			dev_desc->blksz);
#else
wdenk's avatar
wdenk committed
199 200 201
		printf ("            Capacity: %ld.%ld MB = %ld.%ld GB (%ld x %ld)\n",
			mb_quot, mb_rem,
			gb_quot, gb_rem,
202
			(ulong)lba,
wdenk's avatar
wdenk committed
203
			dev_desc->blksz);
204
#endif
wdenk's avatar
wdenk committed
205 206 207 208
	} else {
		puts ("            Capacity: not available\n");
	}
}
209
#endif
wdenk's avatar
wdenk committed
210

211
#ifdef HAVE_BLOCK_DEVICE
wdenk's avatar
wdenk committed
212

213
void part_init(struct blk_desc *dev_desc)
wdenk's avatar
wdenk committed
214
{
215 216 217 218
	struct part_driver *drv =
		ll_entry_start(struct part_driver, part_driver);
	const int n_ents = ll_entry_count(struct part_driver, part_driver);
	struct part_driver *entry;
wdenk's avatar
wdenk committed
219

220 221
	blkcache_invalidate(dev_desc->if_type, dev_desc->devnum);

222
	dev_desc->part_type = PART_TYPE_UNKNOWN;
223 224 225 226 227 228 229 230 231 232
	for (entry = drv; entry != drv + n_ents; entry++) {
		int ret;

		ret = entry->test(dev_desc);
		debug("%s: try '%s': ret=%d\n", __func__, entry->name, ret);
		if (!ret) {
			dev_desc->part_type = entry->part_type;
			break;
		}
	}
wdenk's avatar
wdenk committed
233 234
}

235 236
static void print_part_header(const char *type, struct blk_desc *dev_desc)
{
237 238 239 240 241
#if defined(CONFIG_MAC_PARTITION) || \
	defined(CONFIG_DOS_PARTITION) || \
	defined(CONFIG_ISO_PARTITION) || \
	defined(CONFIG_AMIGA_PARTITION) || \
	defined(CONFIG_EFI_PARTITION)
wdenk's avatar
wdenk committed
242 243
	puts ("\nPartition Map for ");
	switch (dev_desc->if_type) {
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
	case IF_TYPE_IDE:
		puts ("IDE");
		break;
	case IF_TYPE_SATA:
		puts ("SATA");
		break;
	case IF_TYPE_SCSI:
		puts ("SCSI");
		break;
	case IF_TYPE_ATAPI:
		puts ("ATAPI");
		break;
	case IF_TYPE_USB:
		puts ("USB");
		break;
	case IF_TYPE_DOC:
		puts ("DOC");
		break;
Lei Wen's avatar
Lei Wen committed
262 263 264
	case IF_TYPE_MMC:
		puts ("MMC");
		break;
265 266 267
	case IF_TYPE_HOST:
		puts("HOST");
		break;
268 269 270
	default:
		puts ("UNKNOWN");
		break;
wdenk's avatar
wdenk committed
271 272
	}
	printf (" device %d  --   Partition Type: %s\n\n",
273
			dev_desc->devnum, type);
274
#endif /* any CONFIG_..._PARTITION */
275
}
276

277
void part_print(struct blk_desc *dev_desc)
wdenk's avatar
wdenk committed
278
{
279
	struct part_driver *drv;
wdenk's avatar
wdenk committed
280

281 282 283 284
	drv = part_driver_lookup_type(dev_desc->part_type);
	if (!drv) {
		printf("## Unknown partition table type %x\n",
		       dev_desc->part_type);
wdenk's avatar
wdenk committed
285 286
		return;
	}
287 288 289 290 291

	PRINTF("## Testing for valid %s partition ##\n", drv->name);
	print_part_header(drv->name, dev_desc);
	if (drv->print)
		drv->print(dev_desc);
wdenk's avatar
wdenk committed
292 293
}

294
#endif /* HAVE_BLOCK_DEVICE */
295

296
int part_get_info(struct blk_desc *dev_desc, int part,
Pavel Machek's avatar
Pavel Machek committed
297
		       disk_partition_t *info)
298
{
299
#ifdef HAVE_BLOCK_DEVICE
300
	struct part_driver *drv;
301

302 303 304 305
#ifdef CONFIG_PARTITION_UUIDS
	/* The common case is no UUID support */
	info->uuid[0] = 0;
#endif
306 307 308
#ifdef CONFIG_PARTITION_TYPE_GUID
	info->type_guid[0] = 0;
#endif
309

310 311 312 313 314 315 316
	drv = part_driver_lookup_type(dev_desc->part_type);
	if (!drv) {
		debug("## Unknown partition table type %x\n",
		      dev_desc->part_type);
		return -EPROTONOSUPPORT;
	}
	if (!drv->get_info) {
317 318
		PRINTF("## Driver %s does not have the get_info() method\n",
		       drv->name);
319 320 321 322 323
		return -ENOSYS;
	}
	if (drv->get_info(dev_desc, part, info) == 0) {
		PRINTF("## Valid %s partition found ##\n", drv->name);
		return 0;
324
	}
325
#endif /* HAVE_BLOCK_DEVICE */
326 327 328

	return -1;
}
329

330 331
int blk_get_device_by_str(const char *ifname, const char *dev_hwpart_str,
			  struct blk_desc **dev_desc)
Stephen Warren's avatar
Stephen Warren committed
332 333
{
	char *ep;
334 335 336 337 338 339 340 341 342 343 344 345
	char *dup_str = NULL;
	const char *dev_str, *hwpart_str;
	int dev, hwpart;

	hwpart_str = strchr(dev_hwpart_str, '.');
	if (hwpart_str) {
		dup_str = strdup(dev_hwpart_str);
		dup_str[hwpart_str - dev_hwpart_str] = 0;
		dev_str = dup_str;
		hwpart_str++;
	} else {
		dev_str = dev_hwpart_str;
346
		hwpart = 0;
347
	}
Stephen Warren's avatar
Stephen Warren committed
348 349 350 351 352

	dev = simple_strtoul(dev_str, &ep, 16);
	if (*ep) {
		printf("** Bad device specification %s %s **\n",
		       ifname, dev_str);
353
		dev = -EINVAL;
354 355 356 357 358 359 360 361
		goto cleanup;
	}

	if (hwpart_str) {
		hwpart = simple_strtoul(hwpart_str, &ep, 16);
		if (*ep) {
			printf("** Bad HW partition specification %s %s **\n",
			    ifname, hwpart_str);
362
			dev = -EINVAL;
363 364
			goto cleanup;
		}
Stephen Warren's avatar
Stephen Warren committed
365 366
	}

367
	*dev_desc = get_dev_hwpart(ifname, dev, hwpart);
Stephen Warren's avatar
Stephen Warren committed
368
	if (!(*dev_desc) || ((*dev_desc)->type == DEV_TYPE_UNKNOWN)) {
369
		printf("** Bad device %s %s **\n", ifname, dev_hwpart_str);
370
		dev = -ENOENT;
371
		goto cleanup;
Stephen Warren's avatar
Stephen Warren committed
372 373
	}

374 375 376 377 378 379 380
#ifdef HAVE_BLOCK_DEVICE
	/*
	 * Updates the partition table for the specified hw partition.
	 * Does not need to be done for hwpart 0 since it is default and
	 * already loaded.
	 */
	if(hwpart != 0)
381
		part_init(*dev_desc);
382 383
#endif

384 385
cleanup:
	free(dup_str);
Stephen Warren's avatar
Stephen Warren committed
386 387 388
	return dev;
}

389 390 391
#define PART_UNSPECIFIED -2
#define PART_AUTO -1
#define MAX_SEARCH_PARTITIONS 16
392
int blk_get_device_part_str(const char *ifname, const char *dev_part_str,
393
			     struct blk_desc **dev_desc,
394
			     disk_partition_t *info, int allow_whole_dev)
395
{
396 397 398 399
	int ret = -1;
	const char *part_str;
	char *dup_str = NULL;
	const char *dev_str;
400
	int dev;
401 402 403 404 405
	char *ep;
	int p;
	int part;
	disk_partition_t tmpinfo;

406
#ifdef CONFIG_SANDBOX
407
	/*
Pavel Machek's avatar
Pavel Machek committed
408
	 * Special-case a pseudo block device "hostfs", to allow access to the
409 410 411 412 413 414 415 416 417 418 419 420 421
	 * host's own filesystem.
	 */
	if (0 == strcmp(ifname, "hostfs")) {
		*dev_desc = NULL;
		info->start = 0;
		info->size = 0;
		info->blksz = 0;
		info->bootable = 0;
		strcpy((char *)info->type, BOOT_PART_TYPE);
		strcpy((char *)info->name, "Sandbox host");
#ifdef CONFIG_PARTITION_UUIDS
		info->uuid[0] = 0;
#endif
422 423 424
#ifdef CONFIG_PARTITION_TYPE_GUID
		info->type_guid[0] = 0;
#endif
425 426 427

		return 0;
	}
428
#endif
429

Hans de Goede's avatar
Hans de Goede committed
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
#ifdef CONFIG_CMD_UBIFS
	/*
	 * Special-case ubi, ubi goes through a mtd, rathen then through
	 * a regular block device.
	 */
	if (0 == strcmp(ifname, "ubi")) {
		if (!ubifs_is_mounted()) {
			printf("UBIFS not mounted, use ubifsmount to mount volume first!\n");
			return -1;
		}

		*dev_desc = NULL;
		memset(info, 0, sizeof(*info));
		strcpy((char *)info->type, BOOT_PART_TYPE);
		strcpy((char *)info->name, "UBI");
#ifdef CONFIG_PARTITION_UUIDS
		info->uuid[0] = 0;
#endif
		return 0;
	}
#endif

452
	/* If no dev_part_str, use bootdevice environment variable */
453 454
	if (!dev_part_str || !strlen(dev_part_str) ||
	    !strcmp(dev_part_str, "-"))
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
		dev_part_str = getenv("bootdevice");

	/* If still no dev_part_str, it's an error */
	if (!dev_part_str) {
		printf("** No device specified **\n");
		goto cleanup;
	}

	/* Separate device and partition ID specification */
	part_str = strchr(dev_part_str, ':');
	if (part_str) {
		dup_str = strdup(dev_part_str);
		dup_str[part_str - dev_part_str] = 0;
		dev_str = dup_str;
		part_str++;
	} else {
		dev_str = dev_part_str;
472 473
	}

474
	/* Look up the device */
475
	dev = blk_get_device_by_str(ifname, dev_str, dev_desc);
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
	if (dev < 0)
		goto cleanup;

	/* Convert partition ID string to number */
	if (!part_str || !*part_str) {
		part = PART_UNSPECIFIED;
	} else if (!strcmp(part_str, "auto")) {
		part = PART_AUTO;
	} else {
		/* Something specified -> use exactly that */
		part = (int)simple_strtoul(part_str, &ep, 16);
		/*
		 * Less than whole string converted,
		 * or request for whole device, but caller requires partition.
		 */
		if (*ep || (part == 0 && !allow_whole_dev)) {
			printf("** Bad partition specification %s %s **\n",
			    ifname, dev_part_str);
			goto cleanup;
		}
	}

	/*
	 * No partition table on device,
	 * or user requested partition 0 (entire device).
	 */
	if (((*dev_desc)->part_type == PART_TYPE_UNKNOWN) ||
	    (part == 0)) {
		if (!(*dev_desc)->lba) {
			printf("** Bad device size - %s %s **\n", ifname,
			       dev_str);
			goto cleanup;
		}
509

510 511 512 513 514 515 516 517 518
		/*
		 * If user specified a partition ID other than 0,
		 * or the calling command only accepts partitions,
		 * it's an error.
		 */
		if ((part > 0) || (!allow_whole_dev)) {
			printf("** No partition table - %s %s **\n", ifname,
			       dev_str);
			goto cleanup;
519
		}
520

521 522
		(*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);

523
		info->start = 0;
524 525 526
		info->size = (*dev_desc)->lba;
		info->blksz = (*dev_desc)->blksz;
		info->bootable = 0;
527 528
		strcpy((char *)info->type, BOOT_PART_TYPE);
		strcpy((char *)info->name, "Whole Disk");
529 530 531
#ifdef CONFIG_PARTITION_UUIDS
		info->uuid[0] = 0;
#endif
532 533 534
#ifdef CONFIG_PARTITION_TYPE_GUID
		info->type_guid[0] = 0;
#endif
535

536 537
		ret = 0;
		goto cleanup;
538 539
	}

540 541 542 543 544 545 546 547 548 549 550 551
	/*
	 * Now there's known to be a partition table,
	 * not specifying a partition means to pick partition 1.
	 */
	if (part == PART_UNSPECIFIED)
		part = 1;

	/*
	 * If user didn't specify a partition number, or did specify something
	 * other than "auto", use that partition number directly.
	 */
	if (part != PART_AUTO) {
552
		ret = part_get_info(*dev_desc, part, info);
553 554 555 556 557 558 559 560 561 562 563
		if (ret) {
			printf("** Invalid partition %d **\n", part);
			goto cleanup;
		}
	} else {
		/*
		 * Find the first bootable partition.
		 * If none are bootable, fall back to the first valid partition.
		 */
		part = 0;
		for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
564
			ret = part_get_info(*dev_desc, p, info);
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
			if (ret)
				continue;

			/*
			 * First valid partition, or new better partition?
			 * If so, save partition ID.
			 */
			if (!part || info->bootable)
				part = p;

			/* Best possible partition? Stop searching. */
			if (info->bootable)
				break;

			/*
			 * We now need to search further for best possible.
			 * If we what we just queried was the best so far,
			 * save the info since we over-write it next loop.
			 */
			if (part == p)
				tmpinfo = *info;
		}
		/* If we found any acceptable partition */
		if (part) {
			/*
			 * If we searched all possible partition IDs,
			 * return the first valid partition we found.
			 */
			if (p == MAX_SEARCH_PARTITIONS + 1)
				*info = tmpinfo;
		} else {
			printf("** No valid partitions found **\n");
597
			ret = -1;
598 599
			goto cleanup;
		}
600 601 602 603 604
	}
	if (strncmp((char *)info->type, BOOT_PART_TYPE, sizeof(info->type)) != 0) {
		printf("** Invalid partition type \"%.32s\""
			" (expect \"" BOOT_PART_TYPE "\")\n",
			info->type);
605 606
		ret  = -1;
		goto cleanup;
607 608
	}

609 610
	(*dev_desc)->log2blksz = LOG2((*dev_desc)->blksz);

611 612
	ret = part;
	goto cleanup;
613

614 615 616
cleanup:
	free(dup_str);
	return ret;
617
}
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643

int part_get_info_by_name(struct blk_desc *dev_desc, const char *name,
	disk_partition_t *info)
{
	struct part_driver *first_drv =
		ll_entry_start(struct part_driver, part_driver);
	const int n_drvs = ll_entry_count(struct part_driver, part_driver);
	struct part_driver *part_drv;

	for (part_drv = first_drv; part_drv != first_drv + n_drvs; part_drv++) {
		int ret;
		int i;
		for (i = 1; i < part_drv->max_entries; i++) {
			ret = part_drv->get_info(dev_desc, i, info);
			if (ret != 0) {
				/* no more entries in table */
				break;
			}
			if (strcmp(name, (const char *)info->name) == 0) {
				/* matched */
				return 0;
			}
		}
	}
	return -1;
}