/*
* NOTE:
* when CONFIG_SYS_64BIT_LBA is not defined, lbaint_t is 32 bits; this
- * limits the maximum size of addressable storage to < 2 Terra Bytes
+ * limits the maximum size of addressable storage to < 2 tebibytes
*/
-#include <asm/unaligned.h>
#include <common.h>
+#include <blk.h>
+#include <log.h>
+#include <part.h>
+#include <uuid.h>
+#include <asm/cache.h>
+#include <asm/global_data.h>
+#include <asm/unaligned.h>
#include <command.h>
#include <fdtdec.h>
#include <ide.h>
#include <malloc.h>
#include <memalign.h>
#include <part_efi.h>
+#include <dm/ofnode.h>
#include <linux/compiler.h>
#include <linux/ctype.h>
#include <u-boot/crc.h>
-DECLARE_GLOBAL_DATA_PTR;
+#ifdef CONFIG_HAVE_BLOCK_DEVICE
-/*
- * GUID for basic data partions.
- */
+/* GUID for basic data partitons */
+#if CONFIG_IS_ENABLED(EFI_PARTITION)
static const efi_guid_t partition_basic_data_guid = PARTITION_BASIC_DATA_GUID;
+#endif
-#ifdef CONFIG_HAVE_BLOCK_DEVICE
/**
* efi_crc32() - EFI version of crc32 function
* @buf: buffer to calculate crc32 of
static const efi_guid_t system_guid = PARTITION_SYSTEM_GUID;
-static inline int is_bootable(gpt_entry *p)
+static int get_bootable(gpt_entry *p)
{
- return p->attributes.fields.legacy_bios_bootable ||
- !memcmp(&(p->partition_type_guid), &system_guid,
- sizeof(efi_guid_t));
+ int ret = 0;
+
+ if (!memcmp(&p->partition_type_guid, &system_guid, sizeof(efi_guid_t)))
+ ret |= PART_EFI_SYSTEM_PARTITION;
+ if (p->attributes.fields.legacy_bios_bootable)
+ ret |= PART_BOOTABLE;
+ return ret;
}
static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
gpt_entry *gpt_pte = NULL;
int i = 0;
- char uuid[UUID_STR_LEN + 1];
- unsigned char *uuid_bin;
+ unsigned char *uuid;
/* This function validates AND fills in the GPT header and PTE */
if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
printf("\tPartition GUID\n");
for (i = 0; i < le32_to_cpu(gpt_head->num_partition_entries); i++) {
- /* Stop at the first non valid PTE */
+ /* Skip invalid PTE */
if (!is_pte_valid(&gpt_pte[i]))
- break;
+ continue;
printf("%3d\t0x%08llx\t0x%08llx\t\"%s\"\n", (i + 1),
le64_to_cpu(gpt_pte[i].starting_lba),
le64_to_cpu(gpt_pte[i].ending_lba),
print_efiname(&gpt_pte[i]));
printf("\tattrs:\t0x%016llx\n", gpt_pte[i].attributes.raw);
- uuid_bin = (unsigned char *)gpt_pte[i].partition_type_guid.b;
- uuid_bin_to_str(uuid_bin, uuid, UUID_STR_FORMAT_GUID);
- printf("\ttype:\t%s\n", uuid);
-#ifdef CONFIG_PARTITION_TYPE_GUID
- if (!uuid_guid_get_str(uuid_bin, uuid))
- printf("\ttype:\t%s\n", uuid);
-#endif
- uuid_bin = (unsigned char *)gpt_pte[i].unique_partition_guid.b;
- uuid_bin_to_str(uuid_bin, uuid, UUID_STR_FORMAT_GUID);
- printf("\tguid:\t%s\n", uuid);
+ uuid = (unsigned char *)gpt_pte[i].partition_type_guid.b;
+ if (CONFIG_IS_ENABLED(PARTITION_TYPE_GUID))
+ printf("\ttype:\t%pUl\n\t\t(%pUs)\n", uuid, uuid);
+ else
+ printf("\ttype:\t%pUl\n", uuid);
+ uuid = (unsigned char *)gpt_pte[i].unique_partition_guid.b;
+ printf("\tguid:\t%pUl\n", uuid);
}
/* Remember to free pte */
}
int part_get_info_efi(struct blk_desc *dev_desc, int part,
- disk_partition_t *info)
+ struct disk_partition *info)
{
ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
gpt_entry *gpt_pte = NULL;
snprintf((char *)info->name, sizeof(info->name), "%s",
print_efiname(&gpt_pte[part - 1]));
strcpy((char *)info->type, "U-Boot");
- info->bootable = is_bootable(&gpt_pte[part - 1]);
+ info->bootable = get_bootable(&gpt_pte[part - 1]);
#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
uuid_bin_to_str(gpt_pte[part - 1].unique_partition_guid.b, info->uuid,
UUID_STR_FORMAT_GUID);
* set_protective_mbr(): Set the EFI protective MBR
* @param dev_desc - block device descriptor
*
- * @return - zero on success, otherwise error
+ * Return: - zero on success, otherwise error
*/
static int set_protective_mbr(struct blk_desc *dev_desc)
{
int gpt_fill_pte(struct blk_desc *dev_desc,
gpt_header *gpt_h, gpt_entry *gpt_e,
- disk_partition_t *partitions, int parts)
+ struct disk_partition *partitions, int parts)
{
lbaint_t offset = (lbaint_t)le64_to_cpu(gpt_h->first_usable_lba);
lbaint_t last_usable_lba = (lbaint_t)
memset(&gpt_e[i].attributes, 0,
sizeof(gpt_entry_attributes));
- if (partitions[i].bootable)
+ if (partitions[i].bootable & PART_BOOTABLE)
gpt_e[i].attributes.fields.legacy_bios_bootable = 1;
/* partition name */
* from the start of the device) to be specified as a property
* of the device tree '/config' node.
*/
- config_offset = fdtdec_get_config_int(gd->fdt_blob,
- "u-boot,efi-partition-entries-offset",
- -EINVAL);
+ config_offset = ofnode_conf_read_int(
+ "u-boot,efi-partition-entries-offset", -EINVAL);
if (config_offset != -EINVAL) {
offset_bytes = PAD_TO_BLOCKSIZE(config_offset, dev_desc);
offset_blks = offset_bytes / dev_desc->blksz;
}
int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
- disk_partition_t *partitions, int parts_count)
+ struct disk_partition *partitions, int parts_count)
{
gpt_header *gpt_h;
gpt_entry *gpt_e;
/* Free pte before allocating again */
free(*gpt_pte);
+ /*
+ * Check that the alternate_lba entry points to the last LBA
+ */
+ if (le64_to_cpu(gpt_head->alternate_lba) != (dev_desc->lba - 1)) {
+ printf("%s: *** ERROR: Misplaced Backup GPT ***\n",
+ __func__);
+ return -1;
+ }
+
if (is_gpt_valid(dev_desc, (dev_desc->lba - 1),
gpt_head, gpt_pte) != 1) {
printf("%s: *** ERROR: Invalid Backup GPT ***\n",
}
int gpt_verify_partitions(struct blk_desc *dev_desc,
- disk_partition_t *partitions, int parts,
+ struct disk_partition *partitions, int parts,
gpt_header *gpt_head, gpt_entry **gpt_pte)
{
char efi_str[PARTNAME_SZ + 1];
return 1;
}
+ /* Update the partition table entries*/
+ part_init(dev_desc);
+
return 0;
}
#endif
.print = part_print_ptr(part_print_efi),
.test = part_test_efi,
};
-#endif
+#endif /* CONFIG_HAVE_BLOCK_DEVICE */
projects / platform / kernel / u-boot.git / blobdiff