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