[PATCH 1/7] qcom: capsule: add FIT capsule support with multi-partition
Ilias Apalodimas
ilias.apalodimas at linaro.org
Fri May 22 08:48:39 CEST 2026
Hi Balaji,
On Fri, 22 May 2026 at 09:09, Balaji Selvanathan
<balaji.selvanathan at oss.qualcomm.com> wrote:
>
> Add comprehensive FIT capsule update support for Qualcomm platforms
> alongside existing RAW capsule implementation. The new FIT support
> enables multi-partition firmware updates with automatic partition
> discovery.
I am not sure I am following this one? What are you trying to achieve
here? Have a single capsule for all hardware?
Thanks
/Ilias
>
> Refactor qcom_configure_capsule_updates() to use compile-time
> mutual exclusivity between CONFIG_EFI_CAPSULE_FIRMWARE_FIT and
> CONFIG_EFI_CAPSULE_FIRMWARE_RAW using #elif preprocessor directives.
>
> Add board-specific FIT capsule GUIDs for QCS615, QCS6490, and Lemans
> platforms with automatic board detection from device tree compatible
> strings. Each board uses a unique GUID to prevent cross-board
> flashing accidents.
>
> The FIT implementation discovers all SCSI/eMMC partitions across
> multiple devices, applies A/B selection logic based on GPT vendor
> attributes, and generates a comprehensive DFU string for
> multi-partition updates.
>
> A single ESRT entry represents all partitions for simplified firmware
> management.
>
> Signed-off-by: Balaji Selvanathan <balaji.selvanathan at oss.qualcomm.com>
> ---
> arch/arm/mach-snapdragon/capsule_update.c | 740 ++++++++++++++++++++++++++++--
> arch/arm/mach-snapdragon/qcom-priv.h | 23 +
> 2 files changed, 712 insertions(+), 51 deletions(-)
>
> diff --git a/arch/arm/mach-snapdragon/capsule_update.c b/arch/arm/mach-snapdragon/capsule_update.c
> index 586682434b7..d803c46f38d 100644
> --- a/arch/arm/mach-snapdragon/capsule_update.c
> +++ b/arch/arm/mach-snapdragon/capsule_update.c
> @@ -8,30 +8,55 @@
>
> #define pr_fmt(fmt) "QCOM-FMP: " fmt
>
> -#include <dm/device.h>
> -#include <dm/uclass.h>
> +#include <command.h>
> #include <efi.h>
> #include <efi_loader.h>
> #include <malloc.h>
> #include <mmc.h>
> -#include <scsi.h>
> #include <part.h>
> +#include <scsi.h>
> +#include <dm/device.h>
> +#include <dm/uclass.h>
> #include <linux/err.h>
> -
> #include "qcom-priv.h"
>
> /*
> - * To handle different variants like chainloaded U-Boot here we need to
> - * build the fw_images array dynamically at runtime. These are the possible
> - * implementations:
> - *
> - * - Devices with U-Boot on the uefi_a/b partition
> - * - Devices with U-Boot on the boot (a/b) partition
> - * - Devices with U-Boot on the xbl (a/b) partition
> - *
> - * Which partition actually has U-Boot on it is determined based on the
> - * qcom_boot_source variable and additional logic in find_target_partition().
> + * Capsule update support with conditional FIT vs RAW implementation:
> + * - FIT capsules: Comprehensive partition discovery with dynamic fw_images
> + * - RAW capsules: Existing single-partition approach with static fw_images
> */
> +
> +#ifdef CONFIG_EFI_CAPSULE_FIRMWARE_FIT
> +#define MAX_DFU_STRING_SIZE 2048
> +#define MAX_PARTITION_GROUPS 64
> +#define MAX_PARTITIONS_PER_LUN 64
> +#define MAX_PARTITIONS_TO_SCAN 128
> +#define MAX_LUN_GROUPS 16
> +
> +struct qcom_partition_info {
> + char name[32]; /* "uefi_a", "boot_b", etc. */
> + char base_name[32]; /* "uefi", "boot", etc. */
> + char slot_suffix[4]; /* "_a", "_b", or "" */
> + int lun; /* SCSI LUN number */
> + int partition_num; /* Partition number within LUN */
> + bool is_active; /* From GPT vendor attributes */
> + bool is_bootable; /* From GPT vendor attributes */
> +};
> +
> +struct partition_group {
> + char base_name[32];
> + struct qcom_partition_info *a_slot;
> + struct qcom_partition_info *b_slot;
> + struct qcom_partition_info *no_slot;
> +};
> +
> +struct lun_group {
> + int lun_number;
> + struct qcom_partition_info *partitions[MAX_PARTITIONS_PER_LUN]; /* Max partitions per LUN */
> + int partition_count;
> +};
> +#endif /* CONFIG_EFI_CAPSULE_FIRMWARE_FIT */
> +
> struct efi_fw_image fw_images[] = {
> {
> .image_index = 1,
> @@ -39,18 +64,26 @@ struct efi_fw_image fw_images[] = {
> };
>
> struct efi_capsule_update_info update_info = {
> - /* Filled in by configure_dfu_string() */
> + /* Filled in by qcom_configure_capsule_updates() */
> .dfu_string = NULL,
> .num_images = ARRAY_SIZE(fw_images),
> .images = fw_images,
> };
>
> +#ifdef CONFIG_EFI_CAPSULE_FIRMWARE_RAW
> enum target_part_type {
> TARGET_PART_UEFI = 1,
> TARGET_PART_XBL,
> TARGET_PART_BOOT,
> };
>
> +enum ab_slot {
> + SLOT_NONE,
> + SLOT_A,
> + SLOT_B,
> +};
> +#endif /* CONFIG_EFI_CAPSULE_FIRMWARE_RAW */
> +
> /* LSB first */
> struct part_slot_status {
> u16: 2;
> @@ -61,26 +94,6 @@ struct part_slot_status {
> u16 tries_remaining : 4;
> };
>
> -enum ab_slot {
> - SLOT_NONE,
> - SLOT_A,
> - SLOT_B,
> -};
> -
> -static enum ab_slot get_part_slot(const char *partname)
> -{
> - int len = strlen(partname);
> -
> - if (partname[len - 2] != '_')
> - return SLOT_NONE;
> - if (partname[len - 1] == 'a')
> - return SLOT_A;
> - if (partname[len - 1] == 'b')
> - return SLOT_B;
> -
> - return SLOT_NONE;
> -}
> -
> /* Shamelessly copied from lib/efi_loader/efi_device_path.c @ 33 */
> /*
> * Determine if an MMC device is an SD card.
> @@ -98,6 +111,25 @@ static bool is_sd(struct blk_desc *desc)
> return IS_SD(mmc) != 0U;
> }
>
> +#ifdef CONFIG_EFI_CAPSULE_FIRMWARE_RAW
> +/*
> + * RAW Capsule Support
> + */
> +
> +static enum ab_slot get_part_slot(const char *partname)
> +{
> + int len = strlen(partname);
> +
> + if (partname[len - 2] != '_')
> + return SLOT_NONE;
> + if (partname[len - 1] == 'a')
> + return SLOT_A;
> + if (partname[len - 1] == 'b')
> + return SLOT_B;
> +
> + return SLOT_NONE;
> +}
> +
> /*
> * Determine which partition U-Boot is flashed to based on the boot source (ABL/XBL),
> * the slot status, and prioritizing the uefi partition over xbl if found.
> @@ -156,7 +188,7 @@ static int find_target_partition(int *devnum, enum uclass_id *uclass,
> * flags might not be set so we assume the A partition unless the B
> * partition is active.
> */
> - if (!strncmp(info.name, "uefi", strlen("uefi"))) {
> + if (!strncmp(info.name, "uefi_", strlen("uefi_"))) {
> /*
> * If U-Boot was chainloaded somehow we can't be flashed to
> * the uefi partition
> @@ -263,7 +295,7 @@ static int find_target_partition(int *devnum, enum uclass_id *uclass,
> }
>
> /* Found no candidate partitions */
> - return -1;
> + return -ENOENT;
>
> found:
> if (desc) {
> @@ -278,18 +310,7 @@ found:
> return partnum;
> }
>
> -/**
> - * qcom_configure_capsule_updates() - Configure the DFU string for capsule updates
> - *
> - * U-Boot is flashed to the boot partition on Qualcomm boards. In most cases there
> - * are two boot partitions, boot_a and boot_b. As we don't currently support doing
> - * full A/B updates, we only support updating the currently active boot partition.
> - *
> - * So we need to find the current slot suffix and the associated boot partition.
> - * We do this by looking for the boot partition that has the 'active' flag set
> - * in the GPT partition vendor attribute bits.
> - */
> -void qcom_configure_capsule_updates(void)
> +static void configure_raw_capsule_updates(void)
> {
> int ret = 0, partnum = -1, devnum;
> static char dfu_string[32] = { 0 };
> @@ -297,7 +318,6 @@ void qcom_configure_capsule_updates(void)
> enum uclass_id dev_uclass;
>
> if (IS_ENABLED(CONFIG_SCSI)) {
> - /* Scan for SCSI devices */
> ret = scsi_scan(false);
> if (ret) {
> debug("Failed to scan SCSI devices: %d\n", ret);
> @@ -339,7 +359,625 @@ void qcom_configure_capsule_updates(void)
> debug("Unsupported storage uclass: %d\n", dev_uclass);
> return;
> }
> - log_debug("DFU string: '%s'\n", dfu_string);
>
> + log_debug("RAW DFU string: '%s'\n", dfu_string);
> +
> + /* Set RAW configuration state */
> + update_info.dfu_string = dfu_string;
> + update_info.images = fw_images;
> + update_info.num_images = ARRAY_SIZE(fw_images);
> +
> + log_info("RAW capsule update configured (single partition: %s)\n",
> + target_part_type == TARGET_PART_UEFI ? "uefi" :
> + target_part_type == TARGET_PART_XBL ? "xbl" : "boot");
> +}
> +#endif /* CONFIG_EFI_CAPSULE_FIRMWARE_RAW */
> +
> +#ifdef CONFIG_EFI_CAPSULE_FIRMWARE_FIT
> +/*
> + * FIT Capsule Support - Implementation
> + */
> +
> +static void parse_partition_name(const char *full_name, char *base_name, char *slot_suffix)
> +{
> + char *underscore = strrchr(full_name, '_');
> +
> + if (underscore && (strcmp(underscore, "_a") == 0 || strcmp(underscore, "_b") == 0)) {
> + /* Has A/B suffix */
> + size_t base_len = underscore - full_name;
> +
> + strlcpy(base_name, full_name, base_len + 1);
> + strcpy(slot_suffix, underscore);
> + } else {
> + /* No A/B suffix */
> + strcpy(base_name, full_name);
> + slot_suffix[0] = '\0';
> + }
> +}
> +
> +static void parse_partition_info(struct qcom_partition_info *part,
> + struct disk_partition *info,
> + int lun, int partnum)
> +{
> + struct part_slot_status *slot_status;
> +
> + strlcpy(part->name, info->name, sizeof(part->name));
> + part->lun = lun;
> + part->partition_num = partnum;
> +
> + /* Parse slot status from GPT vendor attributes */
> + slot_status = (struct part_slot_status *)&info->type_flags;
> + part->is_active = slot_status->active;
> + part->is_bootable = !slot_status->unbootable;
> +
> + /* Extract base name and slot suffix */
> + parse_partition_name(part->name, part->base_name, part->slot_suffix);
> +}
> +
> +static struct partition_group *find_or_create_group(struct partition_group *groups,
> + int *group_count,
> + const char *base_name)
> +{
> + /* Find existing group */
> + for (int i = 0; i < *group_count; i++) {
> + if (strcmp(groups[i].base_name, base_name) == 0)
> + return &groups[i];
> + }
> +
> + /* Create new group */
> + if (*group_count >= MAX_PARTITION_GROUPS) {
> + log_err("Too many partition groups\n");
> + return NULL;
> + }
> +
> + struct partition_group *new_group = &groups[*group_count];
> +
> + strcpy(new_group->base_name, base_name);
> + new_group->a_slot = NULL;
> + new_group->b_slot = NULL;
> + new_group->no_slot = NULL;
> +
> + (*group_count)++;
> + return new_group;
> +}
> +
> +static struct qcom_partition_info *select_ab_target(struct qcom_partition_info *a_slot,
> + struct qcom_partition_info *b_slot)
> +{
> + /* Priority: Active slot > A slot (fallback) */
> +
> + if (a_slot && a_slot->is_active) {
> + log_debug("Selected %s (active)\n", a_slot->name);
> + return a_slot;
> + }
> + if (b_slot && b_slot->is_active) {
> + log_debug("Selected %s (active)\n", b_slot->name);
> + return b_slot;
> + }
> +
> + /* Both inactive - prefer A slot as fallback */
> + struct qcom_partition_info *fallback = a_slot ? a_slot : b_slot;
> +
> + if (fallback)
> + log_debug("Selected %s (fallback - both inactive)\n", fallback->name);
> + return fallback;
> +}
> +
> +static int discover_all_partitions(struct qcom_partition_info **all_parts, int *all_count)
> +{
> + struct udevice *dev;
> + struct blk_desc *desc;
> + struct qcom_partition_info *partition_list;
> + int partition_count = 0;
> + int max_partitions = 256;
> + bool have_ufs = false;
> +
> + /* Allocate partition list */
> + partition_list = calloc(max_partitions, sizeof(struct qcom_partition_info));
> + if (!partition_list) {
> + log_err("Failed to allocate partition list\n");
> + return -ENOMEM;
> + }
> +
> + if (IS_ENABLED(CONFIG_SCSI)) {
> + if (scsi_scan(false)) {
> + log_debug("Failed to scan SCSI devices\n");
> + free(partition_list);
> + return -EIO;
> + }
> + }
> +
> + /*
> + * Check to see if we have UFS storage, if so firmware MUST be on it and we can skip
> + * all non-UFS block devices
> + */
> + uclass_foreach_dev_probe(UCLASS_UFS, dev) {
> + have_ufs = true;
> + break;
> + }
> +
> + /* Discover partitions with UFS-priority logic */
> + uclass_foreach_dev_probe(UCLASS_BLK, dev) {
> + if (device_get_uclass_id(dev) != UCLASS_BLK)
> + continue;
> +
> + desc = dev_get_uclass_plat(dev);
> + if (!desc)
> + continue;
> +
> + if (have_ufs) {
> + if (device_get_uclass_id(dev->parent->parent) != UCLASS_UFS)
> + continue;
> + } else {
> + /* If we don't have UFS, look at eMMC (but skip SD cards) */
> + if (desc->uclass_id == UCLASS_MMC) {
> + if (IS_ENABLED(CONFIG_MMC) && is_sd(desc)) {
> + log_debug("Skipped SD-Card (devnum %d)\n", desc->devnum);
> + continue;
> + }
> + } else if (desc->uclass_id != UCLASS_SCSI) {
> + /* Not MMC and not SCSI, skip it */
> + continue;
> + }
> + }
> +
> + int lun = desc->devnum;
> +
> + /* Scan all partitions on this device */
> + for (int partnum = 1; partnum <= MAX_PARTITIONS_TO_SCAN; partnum++) {
> + struct disk_partition info;
> +
> + if (part_get_info(desc, partnum, &info) != 0)
> + break;
> +
> + if (partition_count >= max_partitions) {
> + log_warning("Too many partitions discovered, truncating at %d\n",
> + max_partitions);
> + break;
> + }
> +
> + /* Parse and store partition info */
> + parse_partition_info(&partition_list[partition_count], &info, lun, partnum);
> + partition_count++;
> + }
> + }
> +
> + *all_parts = partition_list;
> + *all_count = partition_count;
> +
> + log_debug("Discovered %d partitions across all %s devices\n",
> + partition_count, have_ufs ? "UFS" : "eMMC");
> + return 0;
> +}
> +
> +static int select_target_partitions(struct qcom_partition_info *all_parts, int all_count,
> + struct qcom_partition_info **selected_parts,
> + int *selected_count)
> +{
> + struct partition_group groups[MAX_PARTITION_GROUPS];
> + struct qcom_partition_info *target_list;
> + int group_count = 0;
> + int target_count = 0;
> +
> + memset(groups, 0, sizeof(groups));
> +
> + /* Allocate target list */
> + target_list = calloc(all_count, sizeof(struct qcom_partition_info));
> + if (!target_list) {
> + log_err("Failed to allocate target partition list\n");
> + return -ENOMEM;
> + }
> +
> + /* Group partitions by base name */
> + for (int i = 0; i < all_count; i++) {
> + struct qcom_partition_info *part = &all_parts[i];
> + struct partition_group *group = find_or_create_group(groups, &group_count,
> + part->base_name);
> +
> + if (!group) {
> + log_err("Failed to create group for %s\n", part->base_name);
> + continue;
> + }
> +
> + if (strcmp(part->slot_suffix, "_a") == 0) {
> + if (!group->a_slot) {
> + group->a_slot = part;
> + } else {
> + log_info("Duplicate A-slot partition detected\n");
> + log_info(" Keeping: %s (LUN %d, partition %d) [first discovered]\n",
> + group->a_slot->name, group->a_slot->lun,
> + group->a_slot->partition_num);
> + log_info(" Ignoring: %s (LUN %d, partition %d) [duplicate]\n",
> + part->name, part->lun, part->partition_num);
> + }
> + } else if (strcmp(part->slot_suffix, "_b") == 0) {
> + if (!group->b_slot) {
> + group->b_slot = part;
> + } else {
> + log_info("Duplicate B-slot partition detected\n");
> + log_info(" Keeping: %s (LUN %d, partition %d) [first discovered]\n",
> + group->b_slot->name, group->b_slot->lun,
> + group->b_slot->partition_num);
> + log_info(" Ignoring: %s (LUN %d, partition %d) [duplicate]\n",
> + part->name, part->lun, part->partition_num);
> + }
> + } else {
> + if (!group->no_slot) {
> + group->no_slot = part;
> + } else {
> + log_info("Duplicate non-A/B partition detected\n");
> + log_info(" Keeping: %s (LUN %d, partition %d) [first discovered]\n",
> + group->no_slot->name, group->no_slot->lun,
> + group->no_slot->partition_num);
> + log_info(" Ignoring: %s (LUN %d, partition %d) [duplicate]\n",
> + part->name, part->lun, part->partition_num);
> + }
> + }
> + }
> +
> + log_debug("Created %d partition groups for selection\n", group_count);
> +
> + /* Select target partition for each group */
> + for (int i = 0; i < group_count; i++) {
> + struct partition_group *group = &groups[i];
> + struct qcom_partition_info *target = NULL;
> +
> + if (group->no_slot) {
> + /* Non-A/B partition */
> + target = group->no_slot;
> + log_debug("Group %s: selected non-A/B partition %s\n",
> + group->base_name, target->name);
> + } else {
> + /* A/B partition - apply selection logic */
> + target = select_ab_target(group->a_slot, group->b_slot);
> + if (target) {
> + log_debug("Group %s: selected %s from A/B pair\n",
> + group->base_name, target->name);
> + }
> + }
> +
> + if (target) {
> + /* Copy selected partition to target list */
> + memcpy(&target_list[target_count], target,
> + sizeof(struct qcom_partition_info));
> + target_count++;
> + } else {
> + log_info("No target selected for group %s\n", group->base_name);
> + }
> + }
> +
> + *selected_parts = target_list;
> + *selected_count = target_count;
> +
> + log_debug("Selected %d target partitions from %d discovered\n", target_count, all_count);
> + return 0;
> +}
> +
> +static int group_partitions_by_lun(struct qcom_partition_info *selected_parts, int selected_count,
> + struct lun_group **lun_groups, int *group_count)
> +{
> + struct lun_group *groups;
> + int max_groups = MAX_LUN_GROUPS;
> + int current_groups = 0;
> +
> + /* Allocate LUN groups array */
> + groups = calloc(max_groups, sizeof(struct lun_group));
> + if (!groups) {
> + log_err("Failed to allocate LUN groups array\n");
> + return -ENOMEM;
> + }
> +
> + /* Group partitions by LUN */
> + for (int i = 0; i < selected_count; i++) {
> + struct qcom_partition_info *part = &selected_parts[i];
> + struct lun_group *target_group = NULL;
> +
> + /* Find existing group for this LUN */
> + for (int j = 0; j < current_groups; j++) {
> + if (groups[j].lun_number == part->lun) {
> + target_group = &groups[j];
> + break;
> + }
> + }
> +
> + /* Create new group if not found */
> + if (!target_group) {
> + if (current_groups >= max_groups) {
> + log_err("Too many LUN groups (max %d)\n", max_groups);
> + free(groups);
> + return -ENOSPC;
> + }
> +
> + target_group = &groups[current_groups];
> + target_group->lun_number = part->lun;
> + target_group->partition_count = 0;
> + current_groups++;
> + }
> +
> + /* Add partition to group */
> + if (target_group->partition_count >= 64) {
> + log_err("Too many partitions in LUN %d (max 64)\n", part->lun);
> + free(groups);
> + return -ENOSPC;
> + }
> +
> + target_group->partitions[target_group->partition_count] = part;
> + target_group->partition_count++;
> + }
> +
> + /* Sort groups by LUN number for consistent output */
> + for (int i = 0; i < current_groups - 1; i++) {
> + for (int j = i + 1; j < current_groups; j++) {
> + if (groups[i].lun_number > groups[j].lun_number) {
> + struct lun_group temp = groups[i];
> +
> + groups[i] = groups[j];
> + groups[j] = temp;
> + }
> + }
> + }
> +
> + *lun_groups = groups;
> + *group_count = current_groups;
> +
> + log_debug("Grouped %d partitions into %d LUN groups\n", selected_count, current_groups);
> + return 0;
> +}
> +
> +static int generate_dfu_string(struct qcom_partition_info *selected_parts, int selected_count,
> + char *dfu_string, size_t buffer_size)
> +{
> + struct lun_group *lun_groups = NULL;
> + struct udevice *dev;
> + struct blk_desc *desc;
> + int group_count = 0;
> + char *dfu_ptr = dfu_string;
> + int remaining = buffer_size;
> + int ret;
> + bool is_mmc = false;
> +
> + /* Clear the buffer */
> + memset(dfu_string, 0, buffer_size);
> +
> + /* Determine storage type by checking the first partition's device */
> + if (selected_count > 0) {
> + uclass_foreach_dev_probe(UCLASS_BLK, dev) {
> + if (device_get_uclass_id(dev) != UCLASS_BLK)
> + continue;
> +
> + desc = dev_get_uclass_plat(dev);
> + if (!desc)
> + continue;
> +
> + if (desc->devnum == selected_parts[0].lun) {
> + if (desc->uclass_id == UCLASS_MMC) {
> + is_mmc = true;
> + log_debug("Detected MMC/eMMC storage for DFU string generation\n");
> + } else if (desc->uclass_id == UCLASS_SCSI) {
> + is_mmc = false;
> + log_debug("Detected SCSI/UFS storage for DFU string generation\n");
> + }
> + break;
> + }
> + }
> + }
> +
> + /* Group partitions by LUN/device */
> + ret = group_partitions_by_lun(selected_parts, selected_count, &lun_groups, &group_count);
> + if (ret != 0) {
> + log_err("Failed to group partitions by LUN: %d\n", ret);
> + return ret;
> + }
> +
> + /* Generate DFU string with appropriate format for storage type */
> + for (int i = 0; i < group_count; i++) {
> + struct lun_group *group = &lun_groups[i];
> + int written;
> +
> + /* Add device group separator for non-first groups */
> + if (i > 0) {
> + written = snprintf(dfu_ptr, remaining, "&");
> + dfu_ptr += written;
> + remaining -= written;
> + }
> +
> + if (is_mmc) {
> + /* MMC format: "mmc X=" */
> + written = snprintf(dfu_ptr, remaining, "mmc %d=", group->lun_number);
> + } else {
> + /* SCSI format: "scsi X=" */
> + written = snprintf(dfu_ptr, remaining, "scsi %d=", group->lun_number);
> + }
> + dfu_ptr += written;
> + remaining -= written;
> +
> + /* Add partitions within this device group */
> + for (int j = 0; j < group->partition_count; j++) {
> + struct qcom_partition_info *part = group->partitions[j];
> +
> + /* Add partition separator for non-first partitions in group */
> + if (j > 0) {
> + written = snprintf(dfu_ptr, remaining, ";");
> + dfu_ptr += written;
> + remaining -= written;
> + }
> +
> + if (is_mmc) {
> + /* MMC format: "partition_name part dev_num partition_num" */
> + written = snprintf(dfu_ptr, remaining, "%s part %d %d",
> + part->name, group->lun_number, part->partition_num);
> + } else {
> + /* SCSI format: "partition_name part partition_num" */
> + written = snprintf(dfu_ptr, remaining, "%s part %d",
> + part->name, part->partition_num);
> + }
> + dfu_ptr += written;
> + remaining -= written;
> +
> + if (remaining <= 10) {
> + log_err("DFU string buffer overflow at partition %s\n", part->name);
> + free(lun_groups);
> + return -ENOSPC;
> + }
> + }
> + }
> +
> + /* Clean up */
> + free(lun_groups);
> +
> + log_debug("Generated %s DFU string (%zu chars): %s\n",
> + is_mmc ? "MMC" : "SCSI", strlen(dfu_string), dfu_string);
> + return 0;
> +}
> +
> +/**
> + * get_board_fit_capsule_guid - Get board-specific FIT capsule GUID
> + *
> + * Detect the board type from device tree and return the appropriate GUID
> + * for FIT capsule updates.
> + *
> + * @guid: Pointer to store the GUID
> + * Return: 0 on success, negative error code on failure
> + */
> +static int get_board_fit_capsule_guid(efi_guid_t *guid)
> +{
> + const char *compatible;
> +
> + if (!guid)
> + return -EINVAL;
> +
> + compatible = ofnode_read_string(ofnode_root(), "compatible");
> + if (!compatible) {
> + log_err("Failed to read board compatible string\n");
> + return -ENODEV;
> + }
> +
> + /* Check for QCS615 or Talos */
> + if (strstr(compatible, "qcs615") || strstr(compatible, "talos")) {
> + log_debug("Detected QCS615/Talos board\n");
> + *guid = (efi_guid_t)QCOM_QCS615_FIT_CAPSULE_GUID;
> + return 0;
> + }
> +
> + /* Check for QCS6490 */
> + if (strstr(compatible, "qcs6490")) {
> + log_debug("Detected QCS6490 board\n");
> + *guid = (efi_guid_t)QCOM_QCS6490_FIT_CAPSULE_GUID;
> + return 0;
> + }
> +
> + /* Check for Lemans */
> + if (strstr(compatible, "lemans") || strstr(compatible, "qcs9100")) {
> + log_debug("Detected Lemans board\n");
> + *guid = (efi_guid_t)QCOM_LEMANS_FIT_CAPSULE_GUID;
> + return 0;
> + }
> +
> + log_err("Unsupported board for capsule updates: %s\n", compatible);
> + return -EINVAL;
> +}
> +
> +/*
> + * For creating FIT-based capsule images from FvUpdate.xml files, see:
> + * - Tool: tools/fvupdate_to_fit.py
> + * - Documentation: doc/develop/fvupdate_to_fit.rst
> + */
> +static void configure_fit_capsule_updates(void)
> +{
> + struct qcom_partition_info *all_partitions = NULL;
> + struct qcom_partition_info *selected_partitions = NULL;
> + int all_count = 0, selected_count = 0;
> + static char dfu_string[MAX_DFU_STRING_SIZE] = { 0 };
> + static struct efi_fw_image single_fw_image;
> + efi_guid_t board_guid;
> + int ret;
> +
> + /* Step 1: Discover all partitions across all SCSI LUNs */
> + ret = discover_all_partitions(&all_partitions, &all_count);
> + if (ret != 0) {
> + log_err("Failed to discover SCSI partitions: %d\n", ret);
> + return;
> + }
> +
> + if (all_count == 0) {
> + log_warning("No SCSI partitions discovered\n");
> + goto cleanup;
> + }
> +
> + /* Step 2: Apply A/B selection logic to choose target partitions */
> + ret = select_target_partitions(all_partitions, all_count,
> + &selected_partitions, &selected_count);
> + if (ret != 0) {
> + log_err("Failed to select target partitions: %d\n", ret);
> + goto cleanup;
> + }
> +
> + if (selected_count == 0) {
> + log_warning("No target partitions selected\n");
> + goto cleanup;
> + }
> +
> + /* Step 3: Generate DFU string from selected partitions */
> + ret = generate_dfu_string(selected_partitions, selected_count,
> + dfu_string, sizeof(dfu_string));
> + if (ret != 0) {
> + log_err("Failed to generate DFU string: %d\n", ret);
> + goto cleanup;
> + }
> +
> + /* Step 4: Get board-specific GUID */
> + ret = get_board_fit_capsule_guid(&board_guid);
> + if (ret != 0) {
> + log_err("Failed to get board-specific GUID: %d\n", ret);
> + goto cleanup;
> + }
> +
> + /* Step 5: Create SINGLE fw_image entry for ESRT */
> + memset(&single_fw_image, 0, sizeof(single_fw_image));
> + single_fw_image.fw_name = QCOM_FIT_CAPSULE_NAME; /* Same name for all boards */
> + single_fw_image.image_index = 1;
> + single_fw_image.image_type_id = board_guid;
> +
> + /* Step 6: Configure update_info */
> update_info.dfu_string = dfu_string;
> + update_info.images = &single_fw_image;
> + update_info.num_images = 1;
> +
> + log_info("FIT capsule configured successfully:\n");
> + log_info(" Name: %ls\n", QCOM_FIT_CAPSULE_NAME);
> + log_info(" GUID: %pUl\n", &board_guid);
> + log_info(" Partitions in DFU string: %d\n", selected_count);
> + log_info(" ESRT entries: 1 (single entry for all partitions)\n");
> +
> +cleanup:
> + free(all_partitions);
> + free(selected_partitions);
> +}
> +#endif /* CONFIG_EFI_CAPSULE_FIRMWARE_FIT */
> +
> +/**
> + * qcom_configure_capsule_updates() - Configure capsule updates
> + *
> + * Configures either FIT or RAW capsule updates based on compile-time configuration.
> + */
> +void qcom_configure_capsule_updates(void)
> +{
> +#if defined(CONFIG_EFI_CAPSULE_FIRMWARE_FIT)
> + log_info("Configuring FIT capsule updates\n");
> + configure_fit_capsule_updates();
> +#elif defined(CONFIG_EFI_CAPSULE_FIRMWARE_RAW)
> + log_info("Configuring RAW capsule updates\n");
> + configure_raw_capsule_updates();
> +#else
> + log_warning("No capsule firmware configuration enabled\n");
> +#endif
> +
> + /* Final state logging */
> + if (update_info.dfu_string) {
> + log_info("Capsule update configured successfully with %d image(s)\n",
> + update_info.num_images);
> + } else {
> + log_warning("Capsule update configuration failed\n");
> + }
> }
> +
> diff --git a/arch/arm/mach-snapdragon/qcom-priv.h b/arch/arm/mach-snapdragon/qcom-priv.h
> index b8bf574e8bb..d664c22ae96 100644
> --- a/arch/arm/mach-snapdragon/qcom-priv.h
> +++ b/arch/arm/mach-snapdragon/qcom-priv.h
> @@ -18,6 +18,29 @@ enum qcom_boot_source {
> extern enum qcom_boot_source qcom_boot_source;
>
> #if IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT)
> +/*
> + * Capsule Update GUIDs for FIT capsules
> + * Each board has a unique GUID to prevent cross-board flashing
> + */
> +
> +/* QCS615 FIT Capsule GUID: 9fd379d2-670e-4bb3-86a1-40497e6e17b0 */
> +#define QCOM_QCS615_FIT_CAPSULE_GUID \
> + EFI_GUID(0x9fd379d2, 0x670e, 0x4bb3, 0x86, 0xa1, \
> + 0x40, 0x49, 0x7e, 0x6e, 0x17, 0xb0)
> +
> +/* QCS6490 FIT Capsule GUID: 6f25bfd2-a165-468b-980f-ac51a0a45c52 */
> +#define QCOM_QCS6490_FIT_CAPSULE_GUID \
> + EFI_GUID(0x6f25bfd2, 0xa165, 0x468b, 0x98, 0x0f, \
> + 0xac, 0x51, 0xa0, 0xa4, 0x5c, 0x52)
> +
> +/* Lemans FIT Capsule GUID: 78462415-6133-431c-9fae-48f2bafd5c71 */
> +#define QCOM_LEMANS_FIT_CAPSULE_GUID \
> + EFI_GUID(0x78462415, 0x6133, 0x431c, 0x9f, 0xae, \
> + 0x48, 0xf2, 0xba, 0xfd, 0x5c, 0x71)
> +
> +/* Common name for FIT capsule (same for all boards) */
> +#define QCOM_FIT_CAPSULE_NAME u"QCOM_FIT_CAPSULE"
> +
> void qcom_configure_capsule_updates(void);
> #else
> void qcom_configure_capsule_updates(void) {}
>
> --
> 2.34.1
>
More information about the U-Boot
mailing list