[PATCH 1/7] qcom: capsule: add FIT capsule support with multi-partition
Balaji Selvanathan
balaji.selvanathan at oss.qualcomm.com
Sat May 23 16:33:05 CEST 2026
Hi Ilias,
On 5/23/2026 6:23 PM, Ilias Apalodimas wrote:
> [...]
>
>>>> To support multi-image RAW capsules, we would need to:
>>>>
>>>> 1. Enhance mkeficapsule to create multi-image capsules?
>>> There's an equivalent tool in EDKII that can produce a capsule with
>>> multiple payloads. There were also patches posted for mkeficapsule,
>>> but need some minor tweaks to merge them
>> Can you please point me those patches? I did a search myself, but
>> couldnt find those patches.
> https://lore.kernel.org/u-boot/20240419065542.1160527-1-sughosh.ganu@linaro.org/
Thanks, will ask him to respin.
>
>>>> 2. Enhance efi_firmware_raw_set_image() to parse FMP capsule headers and
>>>> extract multiple binaries?
>>> That's already supported
>> Ohokay, will check the codes.
> This is tested as well, when generating a capsule with multiple
> payloads from EDKII GenerateCapsule tool
Okay.
Regards,
Balaji
>
>>>>>> In contrast, the FIT-based capsule approach uses a single capsule file
>>>>>> to update multiple firmware binaries simultaneously, with the FIT image
>>>>>> serving as a container that bundles all firmware components together.
>>>>>>
>>>>>> 2. The FIT approach (introduced in this series) eliminates hardcoded
>>>>>> partition names: the current Qualcomm RAW capsule update code (in
>>>>>> capsule_update.c) hardcodes partition names like "uefi" in the source
>>>>>> and searches for matching partitions on the device, whereas the
>>>>>> FIT-based method stores partition names as FIT node names within the
>>>>>> capsule itself, allowing the same U-Boot binary to work with different
>>>>>> partition naming schemes without code modification.
>>>>> The UEFI spec does't use names during the update. That's an artificial
>>>>> limitation of your current implementation. The capsule code just looks
>>>>> at the index and the DFU command to update the proper partitions.
>>>> You're correct that the capsule code uses index and DFU commands.
>>>> However, in the current Qualcomm implementation, the DFU string itself
>>>> is built by searching for hardcoded partition names like 'uefi' in the code:
>>>> if (!strncmp(info.name, "uefi_", strlen("uefi_"))) {
>>>> // Build DFU string with this partition
>>>> }
>>> I haven't looked at the code but that sounds like an implementation
>>> detail, that's used to *build* the dfu string dynamically for Qualcomm
>>> platforms. You'll still need that regardless of FIT/RAW capsules,
>>> since you have to define the dfu command. OTOH, you can statically
>>> define that dfu string per platform and remove that part.
>> Okay, will look into this.
> Thanks
> /Ilias
>> Thanks,
>>
>> Balaji
>>
>>> Cheers
>>> /Ilias
>>>> Regards,
>>>>
>>>> Balaji
>>>>
>>>>> Thanks
>>>>> /Ilias
>>>>>> Regards,
>>>>>>
>>>>>> Balaji
>>>>>>
>>>>>>>> Thanks
>>>>>>>> /Ilias
>>>>>>>>> Regards,
>>>>>>>>>
>>>>>>>>> Balaji
>>>>>>>>>
>>>>>>>>>>> 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