Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Christophe KERELLO christophe.kerello@st.com ---
Changes in v6: - invalid offset my_lba in is_secondary_gpt_valid_mtd() the secondary GPT header wasn't detected - add comment for functions
Changes in v5: - solve warning and error (dont' include linux/mtd/mtd.h in part.h)
Changes in v4: None Changes in v3: None Changes in v2: None
disk/Kconfig | 17 ++ disk/Makefile | 1 + disk/part_efi_mtd.c | 456 ++++++++++++++++++++++++++++++++++++++++++++++++++++ doc/README.gpt.mtd | 187 +++++++++++++++++++++ include/part.h | 42 ++++- 5 files changed, 701 insertions(+), 2 deletions(-) create mode 100644 disk/part_efi_mtd.c create mode 100644 doc/README.gpt.mtd
diff --git a/disk/Kconfig b/disk/Kconfig index 9396562..886a089 100644 --- a/disk/Kconfig +++ b/disk/Kconfig @@ -96,6 +96,23 @@ config SPL_EFI_PARTITION depends on SPL && PARTITIONS default y if EFI_PARTITION
+config EFI_PARTITION_MTD + bool "Support EFI GPT over MTD" + depends on EFI_PARTITION + help + The GPT partition is normally defined only for block device with + built-in controller which manage flash translation layer + This option activate the GPT partition support over RAW device + using the MTD framework + - manage partition over MTD devices (as flash: NOR and NAND) + - extract MTD information + - update command gpt, mtdparts and part + +config SPL_EFI_PARTITION_MTD + bool "Enable EFI GPT over MTD for SPL" + depends on SPL_EFI_PARTITION + default y if EFI_PARTITION_MTD + config PARTITION_UUIDS bool "Enable support of UUID for partition" depends on PARTITIONS diff --git a/disk/Makefile b/disk/Makefile index 12c0531..0d01160 100644 --- a/disk/Makefile +++ b/disk/Makefile @@ -13,3 +13,4 @@ obj-$(CONFIG_$(SPL_)DOS_PARTITION) += part_dos.o obj-$(CONFIG_$(SPL_)ISO_PARTITION) += part_iso.o obj-$(CONFIG_$(SPL_)AMIGA_PARTITION) += part_amiga.o obj-$(CONFIG_$(SPL_)EFI_PARTITION) += part_efi.o +obj-$(CONFIG_$(SPL_)EFI_PARTITION_MTD) += part_efi_mtd.o diff --git a/disk/part_efi_mtd.c b/disk/part_efi_mtd.c new file mode 100644 index 0000000..0c83f34 --- /dev/null +++ b/disk/part_efi_mtd.c @@ -0,0 +1,456 @@ +/* + * Copyright (C) 2016 STMicroelectronics . + * Patrick Delaunay patrick.delaunay@st.com + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <asm/unaligned.h> +#include <common.h> +#include <command.h> +#include <ide.h> +#include <inttypes.h> +#include <malloc.h> +#include <memalign.h> +#include <part_efi.h> +#include <linux/ctype.h> +#include <linux/mtd/mtd.h> +#include "part_efi_int.h" + +static int is_primary_gpt_valid_mtd(struct mtd_info *mtd, + lbaint_t lba, + void **buf, + gpt_header **pgpt_head, + gpt_entry **pgpt_pte) +{ + gpt_header *gpt_h; + gpt_entry *gpt_e; + uint32_t size; + uint64_t offset; + int ret; + size_t retlen; + lbaint_t my_lba; + u32 gpt_e_size = PAD_SIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry), + MTD_LBA_SIZE); + + size = gpt_e_size + 2 * MTD_LBA_SIZE; + /* skip bad block */ + offset = 0; + while (mtd_block_isbad(mtd, offset)) { + printf("bad block at 0x%llx\n", offset); + offset += mtd->erasesize; + if (offset >= mtd->size) { + printf("*** ERROR: too many bad block ***\n"); + return -1; + } + } + + debug("primary offset = 0x%llx\n", offset); + /* Read primary GPT from device */ + ret = mtd_read(mtd, offset, size, &retlen, *buf); + if (ret || (retlen != size)) { + printf("*** ERROR: Can't read primary GPT ***\n"); + return -1; + } + + /* determine start of GPT Header & Entries in the buffer */ + gpt_h = *buf + (1 * MTD_LBA_SIZE); + gpt_e = *buf + (2 * MTD_LBA_SIZE); + my_lba = lldiv(offset, MTD_LBA_SIZE) + GPT_PRIMARY_PARTITION_TABLE_LBA; + + if (!validate_gpt_header(gpt_h, my_lba, lba) && + !validate_gpt_entries(gpt_h, gpt_e)) { + *pgpt_head = gpt_h; + *pgpt_pte = gpt_e; + return 0; + } + + return -1; +} + +static int is_secondary_gpt_valid_mtd(struct mtd_info *mtd, + lbaint_t lba, + void **buf, + gpt_header **pgpt_head, + gpt_entry **pgpt_pte) +{ + gpt_header *gpt_h; + gpt_entry *gpt_e; + uint32_t size; + uint64_t offset; + int ret; + size_t retlen; + lbaint_t my_lba; + u32 gpt_e_size = PAD_SIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry), + MTD_LBA_SIZE); + + size = gpt_e_size + 2 * MTD_LBA_SIZE; + /* skip bad block */ + offset = mtd->size; + while (mtd_block_isbad(mtd, offset - mtd->erasesize)) { + offset -= mtd->erasesize; + printf("bad block at 0x%llx\n", offset); + if (offset <= mtd->erasesize) { + printf("*** ERROR: too many bad block ***\n"); + return -1; + } + } + + /* Read backup GPT from device : end of the last valid block */ + size = gpt_e_size + MTD_LBA_SIZE; + + debug("backup offset = 0x%llx\n", offset - size); + ret = mtd_read(mtd, offset - size, size, &retlen, *buf); + if (ret || (retlen != size)) { + printf("*** ERROR: Can't read backup GPT ***\n"); + return -1; + } + + /* determine start of GPT Header & Entries in the buffer */ + gpt_h = *buf + gpt_e_size; + gpt_e = *buf; + my_lba = lldiv(offset, MTD_LBA_SIZE) - 1; + + if (!validate_gpt_header(gpt_h, my_lba, lba) && + !validate_gpt_entries(gpt_h, gpt_e)) { + *pgpt_head = gpt_h; + *pgpt_pte = gpt_e; + return 0; + } + + return -1; +} + +static int is_gpt_valid_mtd(struct mtd_info *mtd, + void **buf, + gpt_header **pgpt_head, + gpt_entry **pgpt_pte) +{ + u32 gpt_e_size = PAD_SIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry), + MTD_LBA_SIZE); + lbaint_t lba; + + if (!mtd || !pgpt_head || !pgpt_pte) { + printf("%s: Invalid Argument(s)\n", __func__); + return 0; + } + + *pgpt_head = NULL; + *pgpt_pte = NULL; + *buf = malloc(gpt_e_size + 2 * MTD_LBA_SIZE); + if (!buf) + return -ENOMEM; + + lba = lldiv(mtd->size, MTD_LBA_SIZE); + if (!is_primary_gpt_valid_mtd(mtd, lba, buf, pgpt_head, pgpt_pte)) + return 1; + + printf("%s: *** ERROR: Invalid GPT ***\n", __func__); + + if (!is_secondary_gpt_valid_mtd(mtd, lba, buf, pgpt_head, pgpt_pte)) { + printf("%s: *** Using Backup GPT ***\n", __func__); + return 1; + } + printf("%s: *** ERROR: Invalid Backup GPT ***\n", __func__); + + free(*buf); + + return 0; +} + +static int gpt_fill_header_mtd(struct mtd_info *mtd, gpt_header *gpt_h, + char *str_guid, int parts_count) +{ + uint32_t erasesize; + uint64_t offset_p_gpt, offset_s_gpt; + __le64 my_lba; + __le64 alternate_lba; + u32 gpt_e_size = PAD_SIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry), + MTD_LBA_SIZE); + + /* one mtd block is not enought for MBR and GPT */ + if ((gpt_e_size + 2 * MTD_LBA_SIZE) > mtd->erasesize) + return -1; + + erasesize = lldiv(mtd->erasesize, MTD_LBA_SIZE); + + /* GPT location : skip bad block */ + offset_p_gpt = 0; + while (mtd_block_isbad(mtd, offset_p_gpt)) { + printf("bad block at 0x%llx\n", offset_p_gpt); + offset_p_gpt += mtd->erasesize; + if (offset_p_gpt >= mtd->size) + return -1; + } + /* primary GPT : 17 first LBA of last good block */ + my_lba = lldiv(offset_p_gpt, MTD_LBA_SIZE) + 1; + + offset_s_gpt = mtd->size; + while (mtd_block_isbad(mtd, offset_s_gpt - mtd->erasesize)) { + offset_s_gpt -= mtd->erasesize; + printf("bad block at 0x%llx\n", offset_s_gpt); + if (offset_s_gpt <= mtd->erasesize) + return -1; + } + /* secondary GPT : 16 LBA of last good block */ + alternate_lba = lldiv(offset_s_gpt, MTD_LBA_SIZE) - 1; + + /* only one good block (primary and secondary on same block) */ + if (offset_p_gpt == ((offset_s_gpt - mtd->erasesize))) + return -1; + + gpt_h->signature = cpu_to_le64(GPT_HEADER_SIGNATURE); + gpt_h->revision = cpu_to_le32(GPT_HEADER_REVISION_V1); + gpt_h->header_size = cpu_to_le32(sizeof(gpt_header)); + gpt_h->my_lba = cpu_to_le64(my_lba); + gpt_h->alternate_lba = cpu_to_le64(alternate_lba); + gpt_h->first_usable_lba = cpu_to_le64(my_lba - 1 + erasesize); + gpt_h->last_usable_lba = cpu_to_le64(alternate_lba - erasesize); + gpt_h->partition_entry_lba = cpu_to_le64(my_lba + 1); + gpt_h->num_partition_entries = cpu_to_le32(GPT_ENTRY_NUMBERS); + gpt_h->sizeof_partition_entry = cpu_to_le32(sizeof(gpt_entry)); + gpt_h->header_crc32 = 0; + gpt_h->partition_entry_array_crc32 = 0; + + if (uuid_str_to_bin(str_guid, gpt_h->disk_guid.b, UUID_STR_FORMAT_GUID)) + return -1; + + return 0; +} + +static int mtd_erase_write_block(struct mtd_info *mtd, + uint64_t offset, + void *buf, + size_t len) +{ + struct erase_info erase; + int ret; + size_t retlen; + u_char *verify_buf; + + erase.mtd = mtd; + erase.len = mtd->erasesize; + erase.addr = offset & ~(mtd->erasesize - 1); /* aligned erase offset */ + erase.callback = NULL; + + debug(" erase at 0x%llx\n", erase.addr); + ret = mtd_erase(mtd, &erase); + if (ret != 0) { + printf("** mark bad block 0x%llx on MTD device %s **\n", + erase.addr, mtd->name); + ret = mtd_block_markbad(mtd, erase.addr); + if (ret) + error("cannot mark bad at offset 0x%llx, error %d", + offset, ret); + return -1; + } + + /* mtd write */ + ret = mtd_write(mtd, offset, len, &retlen, buf); + if (ret != 0) { + error("Write error %d\n", ret); + return ret; + } + + verify_buf = malloc(len); + if (!verify_buf) + return -ENOMEM; + + ret = mtd_read(mtd, offset, len, &retlen, verify_buf); + if (ret) { + error("Read failed 0x%x, %d\n", (u32)offset, ret); + free(verify_buf); + return ret; + } + + if (memcmp(buf, verify_buf, len)) { + error("Verify failed at 0x%x\n", (u32)offset); + return -EIO; + } + + free(verify_buf); + + return 0; +} + +static void prepare_mbr_gpt_header_mtd(void *buf, + struct mtd_info *mtd, + gpt_header *gpt_h, + gpt_entry *gpt_e) +{ + legacy_mbr *p_mbr = buf; + u32 calc_crc32; + + /* Generate CRC for the Primary GPT Header */ + calc_crc32 = efi_crc32((const unsigned char *)gpt_e, + le32_to_cpu(gpt_h->num_partition_entries) * + le32_to_cpu(gpt_h->sizeof_partition_entry)); + gpt_h->partition_entry_array_crc32 = cpu_to_le32(calc_crc32); + + calc_crc32 = efi_crc32((const unsigned char *)gpt_h, + le32_to_cpu(gpt_h->header_size)); + gpt_h->header_crc32 = cpu_to_le32(calc_crc32); + + /* Setup the Protective MBR */ + p_mbr->signature = MSDOS_MBR_SIGNATURE; + p_mbr->partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT; + p_mbr->partition_record[0].start_sect = 1; + p_mbr->partition_record[0].nr_sects = (u32) lldiv(mtd->size, + MTD_LBA_SIZE) - 1; +} + +static int write_gpt_table_mtd(struct mtd_info *mtd, + gpt_header *gpt_h, + gpt_entry *gpt_e) +{ + const int pte_blk_cnt = PAD_COUNT((gpt_h->num_partition_entries + * sizeof(gpt_entry)), MTD_LBA_SIZE); + uint64_t offset; + void *buf; + u32 gpt_e_size = PAD_SIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry), + MTD_LBA_SIZE); + u32 buf_size, p_size, s_size; + + p_size = gpt_e_size + 2 * MTD_LBA_SIZE; + s_size = roundup(gpt_e_size + MTD_LBA_SIZE, mtd->writesize); + buf_size = max(p_size, s_size); + buf = malloc(buf_size); + if (!buf) + return -ENOMEM; + + memset(buf, 0x0, p_size); + + prepare_mbr_gpt_header_mtd(buf, mtd, gpt_h, gpt_e); + + /* GPT Header (1 block) */ + memcpy(buf + (GPT_PRIMARY_PARTITION_TABLE_LBA * MTD_LBA_SIZE), + gpt_h, sizeof(*gpt_h)); + memcpy(buf + ((GPT_PRIMARY_PARTITION_TABLE_LBA + 1) * MTD_LBA_SIZE), + gpt_e, sizeof(gpt_entry) * pte_blk_cnt); + + offset = ALIGN(le64_to_cpu(gpt_h->my_lba - + GPT_PRIMARY_PARTITION_TABLE_LBA) + * MTD_LBA_SIZE, + mtd->erasesize); + + debug("primary offset = 0x%llx\n", offset); + + if (mtd_erase_write_block(mtd, offset, buf, p_size)) + goto err; + + prepare_backup_gpt_header(gpt_h, pte_blk_cnt); + + memset(buf, 0x0, s_size); + + offset = (le64_to_cpu(gpt_h->my_lba) + 1) * MTD_LBA_SIZE - s_size; + memcpy(buf + s_size - MTD_LBA_SIZE, gpt_h, sizeof(*gpt_h)); + memcpy(buf + s_size - MTD_LBA_SIZE - gpt_e_size, + gpt_e, sizeof(gpt_entry) * pte_blk_cnt); + + debug("backup offset = 0x%llx\n", offset); + + if (mtd_erase_write_block(mtd, offset, buf, s_size)) + goto err; + + free(buf); + debug("GPT successfully written to MTD device!\n"); + + return 0; + + err: + free(buf); + printf("** Can't write to MTD device %s **\n", mtd->name); + + return -EIO; +} + +/* + * Public Functions (include/part.h) + */ +int gpt_restore_mtd(struct mtd_info *mtd, char *str_disk_guid, + disk_partition_t *partitions, const int parts_count) +{ + int ret; + gpt_header *gpt_h = calloc(1, PAD_SIZE(sizeof(gpt_header), + MTD_LBA_SIZE)); + gpt_entry *gpt_e; + + if (gpt_h == NULL) { + printf("%s: calloc failed!\n", __func__); + return -ENOMEM; + } + + gpt_e = calloc(1, PAD_SIZE(GPT_ENTRY_NUMBERS + * sizeof(gpt_entry), + MTD_LBA_SIZE)); + if (gpt_e == NULL) { + printf("%s: calloc failed!\n", __func__); + free(gpt_h); + return -ENOMEM; + } + + /* Generate Primary GPT header (LBA1) */ + ret = gpt_fill_header_mtd(mtd, gpt_h, str_disk_guid, parts_count); + if (ret) + goto err; + + /* Generate partition entries */ + ret = gpt_fill_pte(gpt_h, gpt_e, partitions, parts_count); + if (ret) + goto err; + + /* Write GPT partition table */ + ret = write_gpt_table_mtd(mtd, gpt_h, gpt_e); + +err: + free(gpt_e); + free(gpt_h); + + return ret; +} + +void part_print_efi_mtd(struct mtd_info *mtd) +{ + void *buf; + gpt_header *gpt_head; + gpt_entry *gpt_pte; + + if (!is_gpt_valid_mtd(mtd, &buf, &gpt_head, &gpt_pte)) + return; + + part_print_gpt(gpt_head, gpt_pte); + + /* Remember to free buffer */ + free(buf); +} + +int part_get_info_efi_mtd(struct mtd_info *mtd, int part, + disk_partition_t *info) +{ + void *buf; + gpt_header *gpt_head; + gpt_entry *gpt_pte; + + if (!mtd || !info || part < 1) { + printf("%s: Invalid Argument(s)\n", __func__); + return -EINVAL; + } + + if (!is_gpt_valid_mtd(mtd, &buf, &gpt_head, &gpt_pte)) + return -1; + + if (part > le32_to_cpu(gpt_head->num_partition_entries) || + !is_pte_valid(&gpt_pte[part - 1])) { + debug("%s: *** ERROR: Invalid partition number %d ***\n", + __func__, part); + free(buf); + return -EINVAL; + } + + part_get_disk_info(part, MTD_LBA_SIZE, gpt_pte, info); + + /* Remember to free buffer */ + free(buf); + + return 0; +} diff --git a/doc/README.gpt.mtd b/doc/README.gpt.mtd new file mode 100644 index 0000000..326b8f8 --- /dev/null +++ b/doc/README.gpt.mtd @@ -0,0 +1,187 @@ +# +# +# SPDX-License-Identifier: GPL-2.0+ + +Glossary: +======== +- GPT (GUID Partition Table) - it is the EFI standard part +- MTD (Memory Technology Device) - abstraction layer for RAW flah device + +Introduction: +============= +This document describes the GPT support on MTD and usage of +the associated command in U-Boot. + +The GPT is normally defined only for block device with built-in controller +which manage flash translation layer (FTL) as MMC, SD, USB or ATA. + +For raw flash device, the MTD partionning are usally defined in U-Boot +environment and provided to kernel (see mtdparts command). + +U-Boot support GPT for MTD device to save the partition informations of +raw flash device directly in this device (usefull for CONFIG_ENV_IS_NOWHERE) +and to use these informations to support MTD devices in DISTRO without +hardcoded MTD partitioning in U-Boot environment + +The GPT support on top of MTD is defined under CONFIG_EFI_PARTITION_MTD. + +GPT on MTD brief explanation: +============================= + +The GPT standard is respected (header and field meaning). + +The GPT header and each partition need to be eraseblock-align to allow +individual udpate for header or partiton. + +The primary and the backup GPT header are located in the first and +the last -not bad- eraseblock. + +We assume that one eraseblock is enought for MBR and GPT header +(size = 17 KB for 128 entry) + +So it not compatible with the feature CONFIG_SPI_FLASH_USE_4K_SECTORS + + Layout: + ------- + + ---------------------------------------------------------- + LBA 0-33 |Protective MBR + Primary GPT | 1rst eraseblock + -------------------------------------------------- + LBA 34 | (not used) | + LBA N-1 | | + ---------------------------------------------------------- + LBA N |Partition 1 | 2nd eraseblock + | | = first usable + ----------------------------------- + |Partition 2 | + | | + ----------------------------------- last-1 eraseblock + LBA M |Partition n | = last usable + ---------------------------------------------------------- + LBA M+1 | (not used) | last eraseblock + LBA -35 | | + -------------------------------------------------- + LBA -1 to -34 |Backup GPT Header | + ---------------------------------------------------------- + + NB: this layout change (LBA0 and LBA-1) if bad block are present + + GPT header: + ----------- + + for details of GPT header, see README.gpt + + "Current LBA" and "Backup LBA" give the location of the primary and + secondary GPT header. + + All the bad block are detected and skipped when the GPT header is build. + + For Primary GPT: + + - Current LBA = 2nd LBA of the first good eraseblock + + - Backup LBA = Last LBA of the last good block + + - First usable LBA = First LBA of the first usable eraseblock + i.e. the block after primary GPT one + Current LBA - 1 + erase block size + + - Last usable LBA = Last LBA of the last usable eraseblock + i.e. the block before backup GPT one + Backup LBA - erase block size + + Bad Block management (NAND): + --------------------------- + As the bad blocks are skipped, Current LBA and Backup LBA give the real + location of primary and backup GPT header + + warning: the first and the last usable LBA are not guarantee + to be in a good block + + + Typically, the last 4 erase blocks for NAND are used for the bad block + table (BBT, see bbt_options and NAND_BBT_USE_FLASH). + They are indicated bad by MTD framework and they are also skipped. + So the layout for NAND with bad : + + NAND layout with bad blocks: + ---------------------------------------------------------- + N * BAD (*) | | skipped bad + ----------------------------------------------------------- + |Protective MBR | 1rst good eraseblock + |Primary GPT Header | + | | + ------------------------------------------- + | | = first usable + | | + | Partitions | + | | + | | = last usable + ------------------------------------------- + | | + |Backup GPT Header | last good eraseblock + ---------------------------------------------------------- + M * BAD (*) | | skipped bad + ---------------------------------------------------------- + BBT => BAD (*) | | skipped 4 blocks + ---------------------------------------------------------- + (*) BBT and block marked bad are skipped + + +Drawbacks: +========== +1. 2 eraseblocks are used in the device just to save the GPT headers + (primary and backup) + +2. for device with back block (NAND), any read request can disturb the device + so the GPT header should be refreshed when one fixable bit-flip ECC error is + detected... + but it is not the case today + +3. for gpt write the eraseblock for the primary or backup GPT header + (expected good) can become bad for the erase request + + And then U-Boot will mark this block bad + + In this case the first / last usable LBA need to change and to skip the new + bad block, so header need to be recomputed + => the requested gpt write command failed to force new request + PS: the next request will work (skip the new bad block) + + And as the first / last usable LBA can change the same partionning after + the block is marked bad + +GPT on MTD commands: +==================== +some command are modified to support GPT on MTD devices under CONFIG_EFI_PARTITION_MTD + + Creating GPT on MTD partitions: + ------------------------------- + + 1. Define partition layout in the environment. + "partitions=uuid_disk=...;name=u-boot,size=60MiB,uuid=...; + name=kernel,size=60MiB,uuid=...;" + + 2. From U-Boot prompt type: + gpt write nand 0 $partitions + gpt write nor 0 $partitions + + List GPT partition on MTD: + --------------------------------- + part list nand 0 + part list nor 0 + + to find bootable partition (used for distro): + + part list nand 0 -bootable nand_boot_part + part list nor 0 -bootable nor_boot_part + + NB: bootable partition can be used with UBIFS + + Generate MTD partitions from GPT: + --------------------------------- + mtdparts gpt nand0 + mtdparts gpt nor0 + + Then to check mtd partition created with: + mtdparts diff --git a/include/part.h b/include/part.h index b6d1b33..8896b5c 100644 --- a/include/part.h +++ b/include/part.h @@ -311,7 +311,6 @@ int gpt_fill_header(struct blk_desc *dev_desc, gpt_header *gpt_h, */ int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid, disk_partition_t *partitions, const int parts_count); - /** * is_valid_gpt_buf() - Ensure that the Primary GPT information is valid * @@ -366,7 +365,46 @@ int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head, int gpt_verify_partitions(struct blk_desc *dev_desc, disk_partition_t *partitions, int parts, gpt_header *gpt_head, gpt_entry **gpt_pte); -#endif + +#ifdef CONFIG_EFI_PARTITION_MTD + +struct mtd_info; + +#define MTD_LBA_SIZE 512 +/** + * gpt_restore_mtd() - Restore GPT partition table on MTD device + * + * @param mtd - mtd device descriptor + * @param str_disk_guid - disk GUID + * @param partitions - list of partitions + * @param parts_count - number of partitions + * + * @return - '0' on success, otherwise error + */ +int gpt_restore_mtd(struct mtd_info *mtd, char *str_disk_guid, + disk_partition_t *partitions, const int parts_count); + +/* + * part_print_efi() - display GPT Partition information for MTD device + * + * @param mtd_info - pointer to MTD device descriptor + */ +void part_print_efi_mtd(struct mtd_info *mtd_info); + +/* + * part_get_info_efi_mtd() - extract partition information for one GPT entry + * for a MTD device + * + * @param mtd_info - pointer to MTD device descriptor + * @param part - index of entry in gpt_pte + * @param gpt_pte - pointer to disk partition (output) + * + * @return - '0' on success, otherwise error + */ +int part_get_info_efi_mtd(struct mtd_info *mtd, int part, + disk_partition_t *info); +#endif /* CONFIG_EFI_PARTITION_MTD */ +#endif /* CONFIG_EFI_PARTITION */
#if CONFIG_IS_ENABLED(DOS_PARTITION) /**