uuid_guid_parse_str parses a string provided in commands line to found a valid GUID as valid uuid string or as shortcut (under CONFIG_PARTITION_TYPE_GUID).

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com ---

Changes in v6: - rebase of the top of the latest v2017.05

Changes in v5: - rebase of the top of latest u-boot master

Changes in v4: - change RFC to PATCH - update cover letter - rebase on v2017.03

Changes in v3: - solve issue in compute partition_entry_lba update : missing / lba_size - rework and split patches for unrelated change after review from Cristophe Kerello and Simon Glass - rebase on v2017.03-rc1

Changes in v2: - split serie to reduce patches size (separate disk part and cmd impact and add precursor patch) - split large function

include/uuid.h | 1 + lib/uuid.c | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+)

diff --git a/include/uuid.h b/include/uuid.h index c3f423f..f444095 100644 --- a/include/uuid.h +++ b/include/uuid.h @@ -40,6 +40,7 @@ void uuid_bin_to_str(unsigned char *uuid_bin, char *uuid_str, int str_format); int uuid_guid_get_bin(const char *guid_str, unsigned char *guid_bin); int uuid_guid_get_str(unsigned char *guid_bin, char *guid_str); #endif +int uuid_guid_parse_str(const char *str, char *guid_str); void gen_rand_uuid(unsigned char *uuid_bin); void gen_rand_uuid_str(char *uuid_str, int str_format); #endif diff --git a/lib/uuid.c b/lib/uuid.c index c8584ed..7ce822c 100644 --- a/lib/uuid.c +++ b/lib/uuid.c @@ -136,6 +136,41 @@ int uuid_guid_get_str(unsigned char *guid_bin, char *guid_str) #endif

/* + * uuid_guid_parse_str() - this function parses string to found a valid GUID. + * + * @param guid_str - pointer to string with partition type guid [37B] + * or GUID shorcut defined in list_guid[] + * @param guid_str - pointer to allocated partition type string [37B] + * @return 0 if OK, else -ENODEV + */ +int uuid_guid_parse_str(const char *str, char *guid_str) +{ +#ifdef CONFIG_PARTITION_TYPE_GUID + int i; +#endif + + if (guid_str == NULL) + return -ENODEV; + + if (uuid_str_valid(str)) { + memcpy(guid_str, str, UUID_STR_LEN + 1); + return 0; + } + +#ifdef CONFIG_PARTITION_TYPE_GUID + for (i = 0; i < ARRAY_SIZE(list_guid); i++) { + if (!strcmp(list_guid[i].string, str)) { + uuid_bin_to_str((unsigned char *)list_guid[i].guid.b, + guid_str, UUID_STR_FORMAT_GUID); + return 0; + } + } +#endif + + return -ENODEV; +} + +/* * uuid_str_to_bin() - convert string UUID or GUID to big endian binary data. * * @param uuid_str - pointer to UUID or GUID string [37B] or GUID shorcut

create sub-functions part_get_disk_info()

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Christophe KERELLO christophe.kerello@st.com Reviewed-by: Simon Glass sjg@chromium.org ---

Changes in v6: - add comment for function part_get_disk_info

Changes in v5: None Changes in v4: None Changes in v3: None Changes in v2: None

disk/part_efi.c | 57 +++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 35 insertions(+), 22 deletions(-)

diff --git a/disk/part_efi.c b/disk/part_efi.c index 88e925b..16608e7 100644 --- a/disk/part_efi.c +++ b/disk/part_efi.c @@ -216,6 +216,40 @@ static void part_print_gpt(gpt_header *gpt_head, }

/* + * part_get_disk_info() - extract partition information for one GPT entry + * + * @param part - index of entry in gpt_pte + * @param blksz - blksize + * @param gpt_pte - pointer to GPT partion entry array + * @param gpt_pte - pointer to disk partition (output) + */ +static void part_get_disk_info(int part, unsigned int blksz, + gpt_entry *gpt_pte, disk_partition_t *info) +{ + /* The 'lbaint_t' casting may limit the maximum disk size to 2 TB */ + info->start = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].starting_lba); + /* The ending LBA is inclusive, to calculate size, add 1 to it */ + info->size = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].ending_lba) + 1 + - info->start; + info->blksz = blksz; + + sprintf((char *)info->name, "%s", print_efiname(&gpt_pte[part - 1])); + strcpy((char *)info->type, "U-Boot"); + info->bootable = is_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); +#endif +#ifdef CONFIG_PARTITION_TYPE_GUID + uuid_bin_to_str(gpt_pte[part - 1].partition_type_guid.b, + info->type_guid, UUID_STR_FORMAT_GUID); +#endif + + debug("%s: start 0x" LBAF ", size 0x" LBAF ", name %s\n", __func__, + info->start, info->size, info->name); +} + +/* * part_print_efi() - display EFI Partition information * * @param dev_desc - pointer to block device descriptor @@ -283,28 +317,7 @@ int part_get_info_efi(struct blk_desc *dev_desc, int part, return -1; }

- /* The 'lbaint_t' casting may limit the maximum disk size to 2 TB */ - info->start = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].starting_lba); - /* The ending LBA is inclusive, to calculate size, add 1 to it */ - info->size = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].ending_lba) + 1 - - info->start; - info->blksz = dev_desc->blksz; - - sprintf((char *)info->name, "%s", - print_efiname(&gpt_pte[part - 1])); - strcpy((char *)info->type, "U-Boot"); - info->bootable = is_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); -#endif -#ifdef CONFIG_PARTITION_TYPE_GUID - uuid_bin_to_str(gpt_pte[part - 1].partition_type_guid.b, - info->type_guid, UUID_STR_FORMAT_GUID); -#endif - - debug("%s: start 0x" LBAF ", size 0x" LBAF ", name %s\n", __func__, - info->start, info->size, info->name); + part_get_disk_info(part, dev_desc->blksz, gpt_pte, info);

/* Remember to free pte */ free(gpt_pte);

the value for partition_entry_lba of secondary GPT (last usable lba + 1) is not correct with MTD support as last usable LBA need to be erase size aligned

The correct location of partition entry is always recomputed with the formula : partition_entry_lba = alternate_lba - num_pte * sizeof_partition_entry / lba_size

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Christophe KERELLO christophe.kerello@st.com Reviewed-by: Simon Glass sjg@chromium.org --- the device mapping is

1/ for block case:

last_usable_lba -> partition_entry_lba - 1 partition_entry_lba -> PTE table (num * sizeof(PTE)) alternate_lba -> secondary GPT -> end of device

2/ for MTD case : end of the last good block

-------------

last_usable_lba -> last good erase block - 1 -------------erase BLOCK aligned XXXXXXXXXXXXXXXXXX -> skipped LBA for MTD case partition_entry_lba -> PTE table (num * sizeof(PTE)) alternate_lba -> secondary GPT -------------erase BLOCK aligned xxxxx skipping bad block ->end of device

Changes in v6: - add comment for function prepare_backup_gpt_header

Changes in v5: None Changes in v4: None Changes in v3: None Changes in v2: None

disk/part_efi.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/disk/part_efi.c b/disk/part_efi.c index 181a748..23a582a 100644 --- a/disk/part_efi.c +++ b/disk/part_efi.c @@ -155,7 +155,14 @@ static int validate_gpt_entries(gpt_header *gpt_h, gpt_entry *gpt_e) return 0; }

-static void prepare_backup_gpt_header(gpt_header *gpt_h) +/* + * prepare_backup_gpt_header() - change primary GPT header to backup GPT header + * + * @param gpt_h - pointer to GPT header (in=primary, out=secondary) + * @param pte_blk_cnt - number of block for size of partition entry array (PTE) + */ +static void prepare_backup_gpt_header(gpt_header *gpt_h, + const int pte_blk_cnt) { uint32_t calc_crc32; uint64_t val; @@ -164,8 +171,7 @@ static void prepare_backup_gpt_header(gpt_header *gpt_h) val = le64_to_cpu(gpt_h->alternate_lba); gpt_h->alternate_lba = gpt_h->my_lba; gpt_h->my_lba = cpu_to_le64(val); - gpt_h->partition_entry_lba = - cpu_to_le64(le64_to_cpu(gpt_h->last_usable_lba) + 1); + gpt_h->partition_entry_lba = cpu_to_le64(val - pte_blk_cnt); gpt_h->header_crc32 = 0;

calc_crc32 = efi_crc32((const unsigned char *)gpt_h, @@ -409,7 +415,7 @@ int write_gpt_table(struct blk_desc *dev_desc, pte_blk_cnt, gpt_e) != pte_blk_cnt) goto err;

- prepare_backup_gpt_header(gpt_h); + prepare_backup_gpt_header(gpt_h, pte_blk_cnt);

if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba) + 1, pte_blk_cnt, gpt_e) != pte_blk_cnt) @@ -824,7 +830,7 @@ int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf) return 1; }

- prepare_backup_gpt_header(gpt_h); + prepare_backup_gpt_header(gpt_h, gpt_e_blk_cnt);

/* write Backup GPT */ lba = le64_to_cpu(gpt_h->partition_entry_lba);

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) /**

this patch prepare GPT over MTD support blk_desc is only available for block device but not for MTD device

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Simon Glass sjg@chromium.org ---

Changes in v6: None Changes in v5: None Changes in v4: None Changes in v3: None Changes in v2: None

cmd/gpt.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/cmd/gpt.c b/cmd/gpt.c index 3e98821..5dfbce5 100644 --- a/cmd/gpt.c +++ b/cmd/gpt.c @@ -155,7 +155,8 @@ static bool found_key(const char *str, const char *key) * set_gpt_info(): Fill partition information from string * function allocates memory, remember to free! * - * @param dev_desc - pointer block device descriptor + * @param lba - lba index + * @param blksz - block size for device * @param str_part - pointer to string with partition information * @param str_disk_guid - pointer to pointer to allocated string with disk guid * @param partitions - pointer to pointer to allocated partitions array @@ -164,7 +165,8 @@ static bool found_key(const char *str, const char *key) * @return - zero on success, otherwise error * */ -static int set_gpt_info(struct blk_desc *dev_desc, +static int set_gpt_info(unsigned int lba, + unsigned int blksz, const char *str_part, char **str_disk_guid, disk_partition_t **partitions, @@ -179,8 +181,7 @@ static int set_gpt_info(struct blk_desc *dev_desc, uint64_t size_ll, start_ll; lbaint_t offset = 0;

- debug("%s: lba num: 0x%x %d\n", __func__, - (unsigned int)dev_desc->lba, (unsigned int)dev_desc->lba); + debug("%s: lba num: 0x%x %d\n", __func__, lba, lba);

if (str_part == NULL) return -1; @@ -298,7 +299,7 @@ static int set_gpt_info(struct blk_desc *dev_desc, parts[i].size = 0; } else { size_ll = ustrtoull(p, &p, 0); - parts[i].size = lldiv(size_ll, dev_desc->blksz); + parts[i].size = lldiv(size_ll, blksz); }

free(val); @@ -309,7 +310,7 @@ static int set_gpt_info(struct blk_desc *dev_desc, if (extract_env(val, &p)) p = val; start_ll = ustrtoull(p, &p, 0); - parts[i].start = lldiv(start_ll, dev_desc->blksz); + parts[i].start = lldiv(start_ll, blksz); free(val); }

@@ -341,7 +342,7 @@ static int gpt_default(struct blk_desc *blk_dev_desc, const char *str_part) disk_partition_t *partitions = NULL;

/* fill partitions */ - ret = set_gpt_info(blk_dev_desc, str_part, + ret = set_gpt_info(blk_dev_desc->lba, blk_dev_desc->blksz, str_part, &str_disk_guid, &partitions, &part_count); if (ret) { if (ret == -1) @@ -372,7 +373,7 @@ static int gpt_verify(struct blk_desc *blk_dev_desc, const char *str_part) int ret = 0;

/* fill partitions */ - ret = set_gpt_info(blk_dev_desc, str_part, + ret = set_gpt_info(blk_dev_desc->lba, blk_dev_desc->blksz, str_part, &str_disk_guid, &partitions, &part_count); if (ret) { if (ret == -1) {

add a common function between gpt_default and gpt_verify to display the error message associated to errno the patch prepare GPT over MTD, as the same function will be reused

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Christophe KERELLO christophe.kerello@st.com Reviewed-by: Simon Glass sjg@chromium.org ---

Changes in v6: None Changes in v5: None Changes in v4: None Changes in v3: None Changes in v2: None

cmd/gpt.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/cmd/gpt.c b/cmd/gpt.c index a36dbdf..a634071 100644 --- a/cmd/gpt.c +++ b/cmd/gpt.c @@ -334,6 +334,21 @@ err: return errno; }

+/** + * print_gpt_info_err(): display error message for set_gpt_info() + * + * @param ret - value of the result + */ +static void print_gpt_info_err(int ret) +{ + if (ret == -ENOENT) + printf("No partition list provided\n"); + if (ret == -EBADF) + printf("Missing disk guid\n"); + if ((ret == -EFAULT) || (ret == -EINVAL)) + printf("Partition list incomplete\n"); +} + static int gpt_default(struct blk_desc *blk_dev_desc, const char *str_part) { int ret; @@ -345,12 +360,7 @@ static int gpt_default(struct blk_desc *blk_dev_desc, const char *str_part) ret = set_gpt_info(blk_dev_desc->lba, blk_dev_desc->blksz, str_part, &str_disk_guid, &partitions, &part_count); if (ret) { - if (ret == -ENOENT) - printf("No partition list provided\n"); - if (ret == -EBADF) - printf("Missing disk guid\n"); - if ((ret == -EFAULT) || (ret == -EINVAL)) - printf("Partition list incomplete\n"); + print_gpt_info_err(ret); return -1; }

@@ -376,16 +386,12 @@ static int gpt_verify(struct blk_desc *blk_dev_desc, const char *str_part) ret = set_gpt_info(blk_dev_desc->lba, blk_dev_desc->blksz, str_part, &str_disk_guid, &partitions, &part_count); if (ret) { + print_gpt_info_err(ret); if (ret == -ENOENT) { - printf("No partition list provided - only basic check\n"); ret = gpt_verify_headers(blk_dev_desc, gpt_head, &gpt_pte); goto out; } - if (ret == -EBADF) - printf("Missing disk guid\n"); - if ((ret == -EFAULT) || (ret == -EINVAL)) - printf("Partition list incomplete\n"); return -1; }

support part list for MTD device

part list nand 0 part list nor 0

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Simon Glass sjg@chromium.org ---

Changes in v6: None Changes in v5: None Changes in v4: None Changes in v3: None Changes in v2: None

cmd/part.c | 49 +++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 41 insertions(+), 8 deletions(-)

diff --git a/cmd/part.c b/cmd/part.c index 8ba0598..ef5d979 100644 --- a/cmd/part.c +++ b/cmd/part.c @@ -21,6 +21,7 @@ #include <command.h> #include <part.h> #include <vsprintf.h> +#include <linux/mtd/mtd.h>

static int do_part_uuid(int argc, char * const argv[]) { @@ -48,10 +49,14 @@ static int do_part_uuid(int argc, char * const argv[]) static int do_part_list(int argc, char * const argv[]) { int ret; - struct blk_desc *desc; + struct blk_desc *desc = NULL; char *var = NULL; bool bootable = false; int i; +#ifdef CONFIG_EFI_PARTITION_MTD + struct mtd_info *mtd = NULL; + char mtd_dev[16]; +#endif

if (argc < 2) return CMD_RET_USAGE; @@ -77,10 +82,19 @@ static int do_part_list(int argc, char * const argv[]) return CMD_RET_USAGE; }

- ret = blk_get_device_by_str(argv[0], argv[1], &desc); - if (ret < 0) - return 1; - +#ifdef CONFIG_EFI_PARTITION_MTD + if ((strlen(argv[0]) + strlen(argv[1])) < sizeof(mtd_dev)) { + sprintf(mtd_dev, "%s%s", argv[0], argv[1]); + mtd = get_mtd_device_nm(mtd_dev); + } + if (IS_ERR(mtd)) { +#endif + ret = blk_get_device_by_str(argv[0], argv[1], &desc); + if (ret < 0) + return 1; +#ifdef CONFIG_EFI_PARTITION_MTD + } +#endif if (var != NULL) { int p; char str[512] = { '\0', }; @@ -88,10 +102,21 @@ static int do_part_list(int argc, char * const argv[])

for (p = 1; p < 128; p++) { char t[5]; - int r = part_get_info(desc, p, &info); + int r;

- if (r != 0) - continue; + if (desc) { + r = part_get_info(desc, p, &info); + if (r != 0) + continue; + } +#ifdef CONFIG_EFI_PARTITION_MTD + else { + r = part_get_info_efi_mtd(mtd, p, &info); + /* Stop for first non valid partition */ + if (r != 0) + break; + } +#endif

if (bootable && !info.bootable) continue; @@ -100,10 +125,18 @@ static int do_part_list(int argc, char * const argv[]) strcat(str, t); } setenv(var, str); + return 0; }

+#ifndef CONFIG_EFI_PARTITION_MTD part_print(desc); +#else + if (desc) + part_print(desc); + else + part_print_efi_mtd(mtd); +#endif

return 0; }

add new subcommand : mtdparts gpt <mtd-dev> [<GUID>]

extract mtd partition from GPT header present in MTD device

mtdparts gpt nand0 mtdparts gpt nor0

extract mtd partitions only for some GUID

mtdparts gpt nand0 data mtdparts gpt nor0 0FC63DAF-8483-4772-8E79-3D69D8477DE4

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Christophe KERELLO christophe.kerello@st.com Reviewed-by: Simon Glass sjg@chromium.org ---

Changes in v6: None Changes in v5: None Changes in v4: None Changes in v3: None Changes in v2: None

cmd/mtdparts.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 139 insertions(+), 1 deletion(-)

diff --git a/cmd/mtdparts.c b/cmd/mtdparts.c index 796bb98..773a925 100644 --- a/cmd/mtdparts.c +++ b/cmd/mtdparts.c @@ -1902,6 +1902,111 @@ static struct part_info* mtd_part_info(struct mtd_device *dev, unsigned int part return NULL; }

+#ifdef CONFIG_EFI_PARTITION_MTD +/** + * extract MTD info from GPT information + * + * @param device string to select GPT device + * @param p_guid_filter guid for filtering add + * + * @return 0 on success, -ENODEV if no such device otherwise error + */ + +static int mtdparts_gpt(char *device, char *p_guid_filter) +{ + char tmpbuf[PART_ADD_DESC_MAXLEN]; + char size_str[17], start_str[17]; + u8 type, num, len; + struct mtdids *id; + int part_id; + struct mtd_info *mtd; + struct mtd_device *dev; + struct mtd_device *dev_tmp; + disk_partition_t info; + struct part_info *p; + int ret; + + if (mtd_id_parse(device, NULL, &type, &num) != 0) { + printf("invalid MTD device %s\n", device); + return 1; + } + + /* this may be the first run, initialize lists if needed + and make sure we are in sync with env variables */ + mtdparts_init(); + /* don't treat error (mtdparts can be empty) */ + + id = id_find(type, num); + if (id == NULL) { + printf("no such device %s defined in mtdids variable\n", + device); + return -ENODEV; + } + + if (get_mtd_info(type, num, &mtd) || (mtd == NULL)) { + printf("no such MTD device %s\n", device); + return -ENODEV; + } + + for (part_id = 1; part_id <= GPT_ENTRY_NUMBERS; part_id++) { + if (part_get_info_efi_mtd(mtd, part_id, &info)) + break; /* Stop for first non valid partition */ + +#ifdef CONFIG_PARTITION_TYPE_GUID + if (p_guid_filter && + strcmp(p_guid_filter, info.type_guid)) + continue; +#endif + sprintf(size_str, "%llx", (u64)(info.size * info.blksz)); + sprintf(start_str, "%llx", (u64)(info.start * info.blksz)); + + len = strlen(id->mtd_id) + 1; /* 'mtd_id:' */ + len += strlen(size_str) + 2; /* 0x size */ + len += strlen(start_str) + 3; /* @0x start */ + len += strlen((char *)&info.name) + 2; /* '(' name ')' */ + + if (len >= PART_ADD_DESC_MAXLEN) { + printf("too long partition description\n"); + return -EINVAL; + } + + sprintf(tmpbuf, "%s:0x%s@0x%s(%s)", + id->mtd_id, size_str, start_str, info.name); + + debug("add tmpbuf: %s\n", tmpbuf); + + ret = device_parse(tmpbuf, NULL, &dev); + if (ret) + return ret; + + debug("+ %s\t%d\t%s\n", MTD_DEV_TYPE(type), num, + id->mtd_id); + + p = list_entry(dev->parts.next, struct part_info, link); + + dev_tmp = device_find(type, num); + + if (dev_tmp == NULL) { + device_add(dev); + } else { + ret = part_add(dev_tmp, p); + if (ret) { + free(dev); + return ret; + } + } + } + + ret = generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN); + if (ret) { + printf("generated mtdparts too long, resetting to null\n"); + return ret; + } + + return 0; +} +#endif + /***************************************************/ /* U-Boot commands */ /***************************************************/ @@ -1977,6 +2082,31 @@ static int do_mtdparts(cmd_tbl_t *cmdtp, int flag, int argc, } }

+#ifdef CONFIG_EFI_PARTITION_MTD + /* mtdparts gpt <mtd-dev> [GUID] */ + if ((argc == 3 || argc == 4) && (strncmp(argv[1], "gpt", 3) == 0)) { +#ifdef CONFIG_PARTITION_TYPE_GUID + char guid_str[UUID_STR_LEN + 1]; + char *p_guid_filter = NULL; +#endif + + if (argc == 4) { +#ifdef CONFIG_PARTITION_TYPE_GUID + p_guid_filter = guid_str; + if (uuid_guid_parse_str(argv[3], guid_str)) { + printf("invalid type gui %s\n", argv[3]); + return 1; + } + debug("filtered type gui %s (%s)\n", argv[3], guid_str); +#else + puts("type GUI not support\n"); +#endif + } + + return mtdparts_gpt(argv[2], p_guid_filter); + } +#endif + /* make sure we are in sync with env variables */ if (mtdparts_init() != 0) return 1; @@ -2093,6 +2223,10 @@ static char mtdparts_help_text[] = "mtdparts add.spread <mtd-dev> <size>[@<offset>] [<name>] [ro]\n" " - add partition, padding size by skipping bad blocks\n" #endif +#ifdef CONFIG_EFI_PARTITION_MTD + "mtdparts gpt <mtd-dev> [<GUID>]\n" + " - add partitions for device from gpt, filtered by GUID type\n" +#endif "mtdparts default\n" " - reset partition table to defaults\n" #if defined(CONFIG_CMD_MTDPARTS_SPREAD) @@ -2122,7 +2256,11 @@ static char mtdparts_help_text[] = "<size> := standard linux memsize OR '-' to denote all remaining space\n" "<offset> := partition start offset within the device\n" "<name> := '(' NAME ')'\n" - "<ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel)"; + "<ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel)\n" +#ifdef CONFIG_EFI_PARTITION_MTD + "<GUID> := partition guid\n" +#endif + ; #endif

U_BOOT_CMD(

activate needed feature in sandbox to allow test GPT over MTD - EFI_PARTITION_MTD - SPI_FLASH_MTD - CMD_MTDPARTS - MTD_PARTITIONS - MTD_DEVICE

activate 2 features usefull for test - RANDOM_UUID - PARTITION_TYPE_GUID

Signed-off-by: Patrick Delaunay patrick.delaunay@st.com Reviewed-by: Simon Glass sjg@chromium.org ---

Changes in v6: None Changes in v5: None Changes in v4: None Changes in v3: None Changes in v2: None

configs/sandbox_defconfig | 3 +++ include/configs/sandbox.h | 6 ++++++ 2 files changed, 9 insertions(+)

diff --git a/configs/sandbox_defconfig b/configs/sandbox_defconfig index d3fee89..546f837 100644 --- a/configs/sandbox_defconfig +++ b/configs/sandbox_defconfig @@ -57,6 +57,8 @@ CONFIG_CMD_CRAMFS=y CONFIG_CMD_EXT4_WRITE=y CONFIG_MAC_PARTITION=y CONFIG_AMIGA_PARTITION=y +CONFIG_EFI_PARTITION_MTD=y +CONFIG_PARTITION_TYPE_GUID=y CONFIG_OF_CONTROL=y CONFIG_OF_HOSTFILE=y CONFIG_NETCONSOLE=y @@ -110,6 +112,7 @@ CONFIG_SPI_FLASH_SPANSION=y CONFIG_SPI_FLASH_STMICRO=y CONFIG_SPI_FLASH_SST=y CONFIG_SPI_FLASH_WINBOND=y +CONFIG_SPI_FLASH_MTD=y CONFIG_DM_ETH=y CONFIG_PCI=y CONFIG_DM_PCI=y diff --git a/include/configs/sandbox.h b/include/configs/sandbox.h index 37c6132..5fe92b8 100644 --- a/include/configs/sandbox.h +++ b/include/configs/sandbox.h @@ -37,6 +37,12 @@ #define CONFIG_EXT4_WRITE #define CONFIG_HOST_MAX_DEVICES 4

+#define CONFIG_RANDOM_UUID + +/* Dynamic MTD partition support */ +#define CONFIG_CMD_MTDPARTS +#define CONFIG_MTD_PARTITIONS +#define CONFIG_MTD_DEVICE /* * Size of malloc() pool, before and after relocation */