diff --git a/recipes-phosphor/pldm/pldm/0015-Add-Redfish-PDR-support.patch b/recipes-phosphor/pldm/pldm/0015-Add-Redfish-PDR-support.patch
new file mode 100644
index 0000000..2d7ed5a
--- /dev/null
+++ b/recipes-phosphor/pldm/pldm/0015-Add-Redfish-PDR-support.patch
@@ -0,0 +1,1032 @@
+From 964ce7458284b13f500cf7afda61f1fd3d004183 Mon Sep 17 00:00:00 2001
+From: Nikhil Namjoshi <nikhilnamjoshi@google.com>
+Date: Wed, 29 May 2024 04:54:22 +0000
+Subject: [PATCH] Add Redfish PDR support
+
+This change adds support in rded daemon to extract the Redfish
+PDRs from miniBMC using the PLDM M&C Type and Redfish Resource PDR.
+Additionally it removes the previously hardcoded list of resource IDs
+
+Tested: Ran the complete minibmc weekly tests workflow
+including the rde soak tests. All tests passed successfully.
+Verified that the Action commands like Drive reset action also
+work fine.
+
+Fusion-Link: https://fusion2.corp.google.com/c8be2eaa-dfd9-322e-965d-fb2fe908a678
+
+Patch Tracking Bug: b/344927358
+Upstream info / review: NA
+Upstream-Status: Pending
+Justification:
+There is dependency on upstreaming rded first, followed by other
+libpldm command support like OperationInit, Operation,Status,
+OperationComplete and OperationKill. It is possible that we can
+never upstream this support as the upstream did not reach consensus
+for the rded patches.
+
+Google-Bug-Id: 341389695
+Google-Bug-Id: 286465868
+Change-Id: I35dad7d187c0a946f19cd8e144afff9467c83cdd
+Signed-off-by: Nikhil Namjoshi <nikhilnamjoshi@google.com>
+---
+ rded/helper/discovery/platform_discovery.cpp | 354 +++++++++++++++++++
+ rded/helper/discovery/platform_discovery.hpp |  27 ++
+ rded/helper/discovery/rde_discovery.cpp      |  72 +++-
+ rded/helper/discovery/rde_discovery.hpp      |  13 +-
+ rded/helper/resource_id_mapper.hpp           | 221 ------------
+ rded/meson.build                             |   1 +
+ rded/rded.cpp                                |  74 +++-
+ 7 files changed, 513 insertions(+), 249 deletions(-)
+ create mode 100644 rded/helper/discovery/platform_discovery.cpp
+ create mode 100644 rded/helper/discovery/platform_discovery.hpp
+ delete mode 100644 rded/helper/resource_id_mapper.hpp
+
+diff --git a/rded/helper/discovery/platform_discovery.cpp b/rded/helper/discovery/platform_discovery.cpp
+new file mode 100644
+index 0000000..9185025
+--- /dev/null
++++ b/rded/helper/discovery/platform_discovery.cpp
+@@ -0,0 +1,354 @@
++#include "helper/discovery/platform_discovery.hpp"
++
++#include "libpldm/base.h"
++#include "libpldm/platform.h"
++#include "libpldm/pldm.h"
++#include "libpldm/requester/pldm_platform_requester.h"
++#include "libpldm/utils.h"
++
++#include "helper/common.hpp"
++
++#include <cstdint>
++#include <cstring>
++#include <iostream>
++#include <iterator>
++#include <memory>
++#include <unordered_map>
++
++std::unordered_map<uint8_t, int> platformCommandRequestSize = {
++    {PLDM_GET_PDR, PLDM_GET_PDR_REQ_BYTES}};
++
++/**
++ * @brief Sends the current GetPDR request to rde device, decodes
++ * response and stores the response data in containers
++ *
++ * @param[in] fd - Socket Id.
++ * @param[in] eid - Destination EID.
++ * @param[in] instanceId - Instance ID of rde device.
++ * @param[in] netId - Net Id of the rde device.
++ * @param[in] ctx - Pointer to platform requester context
++ * @param[inout] requestMsg - Vector to store requestMsg bytes
++ * @param[inout] resourceIdToSubUriMap - Resource Id to Sub URI map
++ * @param[inout] resourceIdToContainingResourceIdMap - Resource Id to
++ * Containing resource Id map
++ * @param[inout] completePdrRecordBytes - Vector to store the complete Pdr
++ * Record Data bytes
++ */
++static int processGetPdrRequest(
++    int fd, uint8_t eid, int instanceId, int netId,
++    struct pldm_platform_requester_context* ctx,
++    const std::vector<uint8_t>& requestMsg,
++    std::unordered_map<uint32_t, std::string>& resourceIdToSubUriMap,
++    std::unordered_map<uint32_t, uint32_t>& resourceIdToContainingResourceIdMap,
++    std::vector<uint8_t>& completePdrRecordBytes)
++{
++    ctx->requester_status = PLDM_PLATFORM_REQUESTER_WAITING_FOR_RESPONSE;
++    int rc = pldm_send_at_network(eid, netId, fd, requestMsg.data(),
++                                  requestMsg.size());
++    if (rc)
++    {
++        ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++        return PLDM_PLATFORM_REQUESTER_SEND_FAIL;
++    }
++    std::vector<uint8_t> response(sizeof(pldm_msg_hdr) + PLDM_MAX_REQUEST_BYTES,
++                                  0);
++    uint8_t* responseMsg = response.data();
++    size_t responseMsgSize = response.size();
++    auto responsePtr = reinterpret_cast<struct pldm_msg*>(responseMsg);
++    rc = pldm_recv_at_network(eid, fd, instanceId, &responseMsg,
++                              &responseMsgSize, netId);
++    if (rc)
++    {
++        ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++        return PLDM_PLATFORM_REQUESTER_RECV_FAIL;
++    }
++
++    bool isRecordDataComplete = false;
++    size_t recordDataLength = PLDM_MAX_REQUEST_BYTES -
++                              PLDM_GET_PDR_MIN_RESP_BYTES;
++
++    std::vector<uint8_t> recordData(recordDataLength);
++    rc = pldm_platform_push_get_pdr_response(
++        ctx, responsePtr, responseMsgSize, 1 /*expected_pdr_header_version*/,
++        recordData.data(), recordDataLength, &isRecordDataComplete);
++    if (rc)
++    {
++        ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++        std::cerr << "Saving Get PDR Response failed..." << std::endl;
++        return PLDM_PLATFORM_REQUESTER_NOT_RESP_MSG;
++    }
++
++    // Insert all the bytes excluding the command header bytes
++    completePdrRecordBytes.resize(completePdrRecordBytes.size() +
++                                  recordDataLength);
++    std::memcpy((void*)(completePdrRecordBytes.data() +
++                        completePdrRecordBytes.size() - recordDataLength),
++                (void*)(recordData.data() + sizeof(pldm_pdr_hdr)),
++                recordDataLength);
++
++    if (isRecordDataComplete)
++    {
++        uint32_t resourceId = 0;
++        uint8_t resourceFlags = 0;
++        uint32_t containingResourceId = 0;
++        uint16_t proposedContainingResourceLength = 0;
++        char* proposedContainingResourceName = NULL;
++        uint16_t resourceUriLength = 0;
++        char* resourceUri = NULL;
++        uint16_t additionalResourceIdCount = 0;
++        rc = pldm_platform_decode_first_pdr_resource(
++            completePdrRecordBytes.data(), &resourceId, &resourceFlags,
++            &containingResourceId, &proposedContainingResourceLength,
++            &proposedContainingResourceName, &resourceUriLength, &resourceUri,
++            &additionalResourceIdCount);
++        if (rc)
++        {
++            ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++            std::cerr << "Decoding PDR's first resource failed with rc " << rc
++                      << std::endl;
++            return PLDM_PLATFORM_REQUESTER_NOT_RESP_MSG;
++        }
++
++        if (containingResourceId == PLDM_EXTERNAL_RESOURCE_ID)
++        {
++            resourceIdToSubUriMap.emplace(resourceId,
++                                          proposedContainingResourceName);
++        }
++        else
++        {
++            resourceIdToSubUriMap.emplace(resourceId, resourceUri);
++        }
++        resourceIdToContainingResourceIdMap.emplace(resourceId,
++                                                    containingResourceId);
++
++        for (uint16_t id = 0; id < additionalResourceIdCount; id++)
++        {
++            rc = pldm_platform_decode_additional_pdr_resource(
++                completePdrRecordBytes.data(), id, &resourceId,
++                &resourceUriLength, &resourceUri);
++            if (rc)
++            {
++                ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++                std::cerr << "Decoding PDR's additional resource failed..."
++                          << std::endl;
++                return PLDM_PLATFORM_REQUESTER_NOT_RESP_MSG;
++            }
++
++            resourceIdToSubUriMap.emplace(resourceId, resourceUri);
++            resourceIdToContainingResourceIdMap.emplace(resourceId,
++                                                        containingResourceId);
++        }
++
++        // Clear the container so it can be used for next set of PDR data
++        completePdrRecordBytes.clear();
++    }
++
++    return PLDM_PLATFORM_REQUESTER_SUCCESS;
++}
++
++/**
++ * @brief Initializes platform context for the plaform requests
++ *
++ * @param[inout] platformCtx - Pointer to platform requester context
++ * @param[inout] pdrOpCtx - Pointer to pdr operation context
++ * @param[in] rdeDeviceId - Rde device Id
++ * @param[in] netId - Net Id of the rde device.
++ * @param[in] negotiatedTransferSize - Negotiated PLDM message size
++ * @return 0 on success, -1 on failure
++ */
++static int initPlatformContextForRde(
++    struct pldm_platform_requester_context* platformCtx,
++    struct pldm_platform_get_pdr_operation* pdrOpCtx,
++    const std::string& rdeDeviceId, int netId, uint32_t negotiatedTransferSize)
++{
++    if (pldm_platform_init_context(platformCtx, rdeDeviceId.c_str(), netId,
++                                   negotiatedTransferSize) != 0)
++    {
++        std::cerr << "Unable to initialize platform context" << std::endl;
++        return -1;
++    }
++
++    if (pldm_platform_init_get_pdr_operation_context(platformCtx, pdrOpCtx) !=
++        0)
++    {
++        std::cerr << "Unable to initialize GetPDR Operation context"
++                  << std::endl;
++        return -1;
++    }
++
++    return 0;
++}
++
++/**
++ * @brief API to recursively construct complere Redfish resource URI
++ * using the sub URI fragments
++ * @param[in] resourceIdToSubUriMap - Resource ID to Sub Uri map
++ * @param[in] resourceIdToContainingResourceIdMap - Resource ID to
++ * Containing resource ID map
++ * @param[inout] resourcePartialUri - Partially constructed Redfish
++ * resource URI
++ * @param[in] containingResourceId - Containing Resource ID
++ * @return string representing the complete Redfish resource URI
++ */
++static std::string constructResourceUri(
++    const std::unordered_map<uint32_t, std::string>& resourceIdToSubUriMap,
++    const std::unordered_map<uint32_t, uint32_t>&
++        resourceIdToContainingResourceIdMap,
++    std::string& resourcePartialUri, uint32_t containingResourceId)
++{
++    // Break the recusion when the resource is root level resource
++    if (containingResourceId == 0x00000000)
++    {
++        return "/redfish/v1/" + resourcePartialUri;
++    }
++
++    auto resourceIdToSubUriMapItr =
++        resourceIdToSubUriMap.find(containingResourceId);
++    if (resourceIdToSubUriMapItr == resourceIdToSubUriMap.end())
++    {
++        std::cerr << "Cannot find containingResourceId : "
++                  << containingResourceId << " in resourceIdToSubUriMap"
++                  << std::endl;
++        return "";
++    }
++
++    std::string subUri = resourceIdToSubUriMapItr->second;
++
++    resourcePartialUri = subUri + "/" + resourcePartialUri;
++
++    auto resourceIdToContainingResourceIdMapItr =
++        resourceIdToContainingResourceIdMap.find(containingResourceId);
++    if (resourceIdToContainingResourceIdMapItr ==
++        resourceIdToContainingResourceIdMap.end())
++    {
++        std::cerr << "Cannot find containingResourceId : "
++                  << containingResourceId
++                  << " in resourceIdToContainingResourceIdMap" << std::endl;
++        return "";
++    }
++
++    uint32_t nextContainingResourceId =
++        resourceIdToContainingResourceIdMapItr->second;
++    return constructResourceUri(resourceIdToSubUriMap,
++                                resourceIdToContainingResourceIdMap,
++                                resourcePartialUri, nextContainingResourceId);
++}
++
++/**
++ * @brief API to recursively construct Redfish resource URI
++ * to Resource ID Map
++ * @param[inout] resourceIdMap - Redfish Resource URI to Resource ID map
++ * @param[in] resourceIdToSubUriMap - Resource ID to Sub Uri map
++ * @param[in] resourceIdToContainingResourceIdMap - Resource ID to
++ * Containing resource ID map
++ * @return string representing the complete Redfish resource URI
++ */
++static void constructResourceIdMap(
++    std::unordered_map<std::string, uint32_t>& resourceIdMap,
++    const std::unordered_map<uint32_t, std::string>& resourceIdToSubUriMap,
++    const std::unordered_map<uint32_t, uint32_t>&
++        resourceIdToContainingResourceIdMap)
++{
++    for (auto it = resourceIdToContainingResourceIdMap.begin();
++         it != resourceIdToContainingResourceIdMap.end(); ++it)
++    {
++        uint32_t resourceId = it->first;
++        uint32_t containingResourceId = it->second;
++
++        auto resourceIdToSubUriMapItr = resourceIdToSubUriMap.find(resourceId);
++        if (resourceIdToSubUriMapItr == resourceIdToSubUriMap.end())
++        {
++            std::cerr << "Cannot find resourceId : " << resourceId
++                      << " in resourceIdToSubUriMap" << std::endl;
++            return;
++        }
++
++        std::string resourcePartialUri = resourceIdToSubUriMapItr->second;
++        std::string resourceFullUri = constructResourceUri(
++            resourceIdToSubUriMap, resourceIdToContainingResourceIdMap,
++            resourcePartialUri, containingResourceId);
++        std::cerr << "Adding resourceId " << std::showbase << std::hex
++                  << resourceId << " with resource URI " << resourceFullUri
++                  << std::endl;
++        resourceIdMap.emplace(resourceFullUri, resourceId);
++    }
++}
++
++int performPdrDiscovery(
++    const std::string& rdeDeviceId, int fd, int netId, uint8_t destEid,
++    uint8_t instanceId, uint32_t negotiatedTransferSize,
++    std::unordered_map<std::string, uint32_t>& resourceIdMap)
++{
++    struct pldm_platform_requester_context platformContext;
++    struct pldm_platform_get_pdr_operation pdrOpContext;
++
++    int rc = initPlatformContextForRde(&platformContext, &pdrOpContext,
++                                       rdeDeviceId, netId,
++                                       negotiatedTransferSize);
++    if (rc)
++    {
++        return -1;
++    }
++
++    rc = pldm_platform_start_pdr_discovery(&platformContext);
++    if (rc)
++    {
++        std::cerr << "PDR Discovery failed due to context busy with ec: " << rc
++                  << std::endl;
++        return -1;
++    }
++
++    std::unordered_map<uint32_t, std::string> resourceIdToSubUriMap;
++    std::unordered_map<uint32_t, uint32_t> resourceIdToContainingResourceIdMap;
++    std::vector<uint8_t> completePdrRecordBytes;
++
++    std::cerr << "Sending Platform PDR Discovery requests." << std::endl;
++
++    while (true)
++    {
++        size_t requestBytes;
++        if (platformContext.requester_status ==
++            PLDM_PLATFORM_REQUESTER_NO_PENDING_ACTION)
++        {
++            break;
++        }
++        if (platformCommandRequestSize.find(platformContext.next_command) !=
++            platformCommandRequestSize.end())
++        {
++            requestBytes =
++                platformCommandRequestSize[platformContext.next_command];
++        }
++        else
++        {
++            requestBytes = PLDM_MAX_REQUEST_BYTES;
++        }
++
++        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) + requestBytes);
++        auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
++
++        rc = pldm_platform_get_next_get_pdr_request(
++            &platformContext, instanceId, request, requestBytes);
++        if (rc)
++        {
++            std::cerr << "Not a valid request to process" << std::endl;
++            return rc;
++        }
++
++        rc = processGetPdrRequest(fd, destEid, 1, netId, &platformContext,
++                                  requestMsg, resourceIdToSubUriMap,
++                                  resourceIdToContainingResourceIdMap,
++                                  completePdrRecordBytes);
++
++        if (rc)
++        {
++            std::cerr << "Unable to process next platform request: "
++                      << std::to_string(rc) << std::endl;
++            return rc;
++        }
++    }
++
++    std::cerr << "PDR Discovery complete." << std::endl;
++    constructResourceIdMap(resourceIdMap, resourceIdToSubUriMap,
++                           resourceIdToContainingResourceIdMap);
++    return 0;
++}
+diff --git a/rded/helper/discovery/platform_discovery.hpp b/rded/helper/discovery/platform_discovery.hpp
+new file mode 100644
+index 0000000..864af62
+--- /dev/null
++++ b/rded/helper/discovery/platform_discovery.hpp
+@@ -0,0 +1,27 @@
++#include "libpldm/requester/pldm_platform_requester.h"
++
++#include <iostream>
++#include <optional>
++#include <string>
++#include <unordered_map>
++#include <vector>
++
++#pragma once
++
++/**
++ * @brief Collects all the PDRs from rde device
++ *
++ * @param[in] rdeDeviceId - Udev Id of the rde device.
++ * @param[in] fd - Socket Id.
++ * @param[in] netId - Net Id of the rde device.
++ * @param[in] destEid - Destination EID.
++ * @param[in] instanceId - Instance ID of rde device.
++ * @param[in] negotiatedTransferSize - Pldm msg transfer size negotiated with
++ * rde device.
++ * @param[inout] resourceIdMap - Map of resource URI against resource Id.
++ * @return 0 on success and negative errono on failure
++ */
++int performPdrDiscovery(
++    const std::string& rdeDeviceId, int fd, int netId, uint8_t destEid,
++    uint8_t instanceId, uint32_t negotiatedTransferSize,
++    std::unordered_map<std::string, uint32_t>& resourceIdMap);
+diff --git a/rded/helper/discovery/rde_discovery.cpp b/rded/helper/discovery/rde_discovery.cpp
+index 3ccae41..37e475e 100644
+--- a/rded/helper/discovery/rde_discovery.cpp
++++ b/rded/helper/discovery/rde_discovery.cpp
+@@ -1,5 +1,3 @@
+-#include "helper/discovery/rde_discovery.hpp"
+-
+ #include "libpldm/base.h"
+ #include "libpldm/pldm.h"
+ #include "libpldm/pldm_rde.h"
+@@ -7,7 +5,9 @@
+ #include "libpldm/utils.h"
+ 
+ #include "helper/common.hpp"
++#include "helper/discovery/rde_discovery.hpp"
+ 
++#include <algorithm>
+ #include <cstdint>
+ #include <iostream>
+ #include <map>
+@@ -139,11 +139,6 @@ int initManager(const std::string& rdeDeviceId, int netId)
+     std::unique_ptr<bitfield16_t> mcFeatures = std::make_unique<bitfield16_t>();
+     mcFeatures->value = 102; // Fixed for now
+     std::cout << "Initializing RDE Manager...\n";
+-    std::vector<uint32_t> resourceIds = {
+-        0x00000000, 0x00010000, 0x00020000, 0x00030000, 0x00040000,
+-        0x00050000, 0x00060000, 0x00070000, 0x00080000, 0x00090000,
+-        0x000a0000, 0x000b0000, 0x000c0000, 0x000d0000, 0x000e0000,
+-        0x000f0000, 0x00100000, 0x00110000, 0xffffffff};
+ 
+     std::unique_ptr<struct pldm_rde_requester_manager> manager =
+         std::make_unique<struct pldm_rde_requester_manager>();
+@@ -151,8 +146,7 @@ int initManager(const std::string& rdeDeviceId, int netId)
+     managerCtxCounter.insert({rdeDeviceId, rdeContextCounter});
+     int rc = pldm_rde_init_context(
+         rdeDeviceId.c_str(), netId, manager.get(), mcConcurrency,
+-        mcTransferSize, mcFeatures.get(), resourceIds.size(),
+-        &resourceIds.front(), allocateMemoryToContexts, freeMemory);
++        mcTransferSize, mcFeatures.get(), allocateMemoryToContexts, freeMemory);
+ 
+     if (rc)
+     {
+@@ -168,6 +162,18 @@ int initManager(const std::string& rdeDeviceId, int netId)
+     return PLDM_RDE_REQUESTER_SUCCESS;
+ }
+ 
++/**
++ * @param[in] manager - Rde manager for the device
++ * @param[in] resourceIds - List of dictionary schema resource IDs
++ * @return 0 on success, non zero error code on failure.
++ */
++static int setResourcesIdsInManager(struct pldm_rde_requester_manager* manager,
++                                    std::vector<uint32_t>& resourceIds)
++{
++    return pldm_rde_set_resources_in_context(manager, resourceIds.size(),
++                                             resourceIds.data());
++}
++
+ int getRdeContextForRdeDevice(const std::string& rdeDevice)
+ {
+     auto it = managerCtxCounter.find(rdeDevice);
+@@ -542,7 +548,8 @@ int processNextRdeRequest(int fd, uint8_t eid, int instanceId,
+ }
+ 
+ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+-                        uint8_t destEid, uint8_t instanceId)
++                        uint8_t destEid, uint8_t instanceId,
++                        uint32_t& negotiatedTransferSize)
+ {
+     int rc = initManager(rdeDeviceId, netId);
+ 
+@@ -625,6 +632,8 @@ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+         }
+     }
+ 
++    negotiatedTransferSize = manager->negotiated_transfer_size;
++
+     if (DEBUG)
+     {
+         printRDENegotiateContext(manager);
+@@ -632,12 +641,35 @@ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+     return rc;
+ }
+ 
+-int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+-                                        uint8_t destEid, uint8_t instanceId)
++int performDictionaryDiscoveryForDevice(
++    const std::string& rdeDeviceId, int fd, uint8_t destEid, uint8_t instanceId,
++    std::unordered_map<std::string, uint32_t>& resourceIdMap)
+ {
+     std::unordered_map<uint32_t, std::vector<uint8_t>> dictionaryRidMap;
+     std::unordered_map<uint32_t, std::tuple<uint8_t, uint8_t>>
+         dictionaryMetaRidMap;
++    std::vector<uint32_t> schemaResourceIds;
++
++    for (const auto& [key, value] : resourceIdMap)
++    {
++        // We need to extract just the schema resource IDs. There will be
++        // multiple resources which share the same schema, but we only need
++        // the resource ID of the first resource of that schema
++        // For e.g. We only need resource ID of /redfish/v1/Chassis/Tray i.e.
++        // 0x00020000 instead of resource ID of /redfish/v1/Chassis/SATA_0 i.e.
++        // 0x00020001. Here the MSB 0x0002 represents the resource type while
++        // the LSB 0x0001 represent the resource index. So we exclude the
++        // resource index
++        uint32_t schemaResourceId = value & 0xFFFF0000;
++        auto it = std::find(schemaResourceIds.begin(), schemaResourceIds.end(),
++                            schemaResourceId);
++        if (it == schemaResourceIds.end())
++        {
++            schemaResourceIds.emplace_back(schemaResourceId);
++        }
++    }
++    // Add the annotation dictionary
++    schemaResourceIds.emplace_back(0xffffffff);
+ 
+     dictionaryDeviceMap.insert({rdeDeviceId, dictionaryRidMap});
+ 
+@@ -678,6 +710,15 @@ int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+     }
+     struct pldm_rde_requester_manager* manager = managerOpt.value();
+ 
++    rc = setResourcesIdsInManager(manager, schemaResourceIds);
++    if (rc)
++    {
++        std::cerr
++            << "RDE Discovery failed due to failed to set resource IDs in context: "
++            << rc << "\n";
++        return -1;
++    }
++
+     std::cout << "Getting Dictionaries..." << std::endl;
+     int retryCounter = 0;
+     while (retryCounter < MAX_RETRIES_FOR_REQUEST)
+@@ -704,7 +745,7 @@ int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+         {
+             std::cerr << "Getting dictionary for "
+                       << manager->resource_ids[baseContext.current_pdr_resource
+-                                         ->resource_id_index]
++                                                   ->resource_id_index]
+                       << "..." << std::endl;
+         }
+ 
+@@ -733,7 +774,8 @@ int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+ }
+ 
+ int getRdeFreeContextForRdeDevice(
+-    const std::string& rdeDevice, struct pldm_rde_requester_context* baseContext)
++    const std::string& rdeDevice,
++    struct pldm_rde_requester_context* baseContext)
+ {
+     auto it = managerCtxCounter.find(rdeDevice);
+     if (it != managerCtxCounter.end())
+@@ -756,7 +798,7 @@ int getDictionaryForRidDev(const std::string& rdeDeviceId, uint32_t resourceId,
+ 
+     std::optional<std::unordered_map<uint32_t, std::vector<uint8_t>>*>
+         dictionaryRidMapOpt = getDictionaryMap(rdeDeviceId);
+-    
++
+     if (!dictionaryRidMapOpt.has_value())
+     {
+         std::cerr << "Unable to fetch dictionary from map while storing\n";
+diff --git a/rded/helper/discovery/rde_discovery.hpp b/rded/helper/discovery/rde_discovery.hpp
+index 1e5efa7..e40fc31 100644
+--- a/rded/helper/discovery/rde_discovery.hpp
++++ b/rded/helper/discovery/rde_discovery.hpp
+@@ -1,9 +1,10 @@
+ #include "libpldm/requester/pldm_rde_requester.h"
+ 
+ #include <iostream>
++#include <optional>
+ #include <string>
++#include <unordered_map>
+ #include <vector>
+-#include <optional>
+ 
+ #pragma once
+ 
+@@ -12,10 +13,12 @@
+ #define RDE_GET_DICT_SCHEMA_RESP_SIZE 6
+ 
+ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+-                        uint8_t destEid, uint8_t instanceId);
++                        uint8_t destEid, uint8_t instanceId,
++                        uint32_t& negotiatedTransferSize);
+ 
+-int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+-                                        uint8_t destEid, uint8_t instanceId);
++int performDictionaryDiscoveryForDevice(
++    const std::string& rdeDeviceId, int fd, uint8_t destEid, uint8_t instanceId,
++    std::unordered_map<std::string, uint32_t>& resourceIdMap);
+ 
+ void cleanupDictionaries(const std::string& rdeDeviceId);
+ 
+@@ -33,4 +36,4 @@ std::optional<struct pldm_rde_requester_manager*>
+ void cleanupDictionaries(const std::string& rdeDeviceId);
+ 
+ // cleanup disc data at exit
+-void cleanupRdeDiscAtExit();
+\ No newline at end of file
++void cleanupRdeDiscAtExit();
+diff --git a/rded/helper/resource_id_mapper.hpp b/rded/helper/resource_id_mapper.hpp
+deleted file mode 100644
+index c605cb4..0000000
+--- a/rded/helper/resource_id_mapper.hpp
++++ /dev/null
+@@ -1,221 +0,0 @@
+-/**
+- *
+- * This file has a hardcoded resource id mapper for machines
+- * This would not be used once the PDR is implemented
+- *
+- */
+-#include <iostream>
+-#include <string>
+-#include <string_view>
+-#include <unordered_map>
+-
+-std::unordered_map<std::string_view, uint32_t> resourceIdMap = {
+-    {"/redfish/v1/Chassis", 0x00000000},
+-    {"/redfish/v1/Chassis/Tray", 0x00010000},
+-    {"/redfish/v1/Chassis/SATA_0", 0x00010001},
+-    {"/redfish/v1/Chassis/SATA_1", 0x00010002},
+-    {"/redfish/v1/Chassis/SATA_2", 0x00010003},
+-    {"/redfish/v1/Chassis/SATA_3", 0x00010004},
+-    {"/redfish/v1/Chassis/SATA_4", 0x00010005},
+-    {"/redfish/v1/Chassis/SATA_5", 0x00010006},
+-    {"/redfish/v1/Chassis/SATA_6", 0x00010007},
+-    {"/redfish/v1/Chassis/SATA_7", 0x00010008},
+-    {"/redfish/v1/Chassis/SATA_8", 0x00010009},
+-    {"/redfish/v1/Chassis/SATA_9", 0x0001000a},
+-    {"/redfish/v1/Chassis/SATA_10", 0x0001000b},
+-    {"/redfish/v1/Chassis/SATA_11", 0x0001000c},
+-    {"/redfish/v1/Chassis/SATA_12", 0x0001000d},
+-    {"/redfish/v1/Chassis/SATA_13", 0x0001000e},
+-    {"/redfish/v1/Chassis/SATA_14", 0x0001000f},
+-    {"/redfish/v1/Chassis/SATA_15", 0x00010010},
+-    {"/redfish/v1/Chassis/SATA_16", 0x00010011},
+-    {"/redfish/v1/Chassis/SATA_17", 0x00010012},
+-    {"/redfish/v1/Chassis/SATA_18", 0x00010013},
+-    {"/redfish/v1/Chassis/SATA_19", 0x00010014},
+-    {"/redfish/v1/Chassis/SATA_20", 0x00010015},
+-    {"/redfish/v1/Chassis/SATA_21", 0x00010016},
+-    {"/redfish/v1/Chassis/SATA_22", 0x00010017},
+-    {"/redfish/v1/Chassis/SATA_23", 0x00010018},
+-    {"/redfish/v1/Chassis/Tray/Sensors", 0x00020000},
+-    {"/redfish/v1/Chassis/SATA_0/Sensors", 0x00020001},
+-    {"/redfish/v1/Chassis/SATA_1/Sensors", 0x00020002},
+-    {"/redfish/v1/Chassis/SATA_2/Sensors", 0x00020003},
+-    {"/redfish/v1/Chassis/SATA_3/Sensors", 0x00020004},
+-    {"/redfish/v1/Chassis/SATA_4/Sensors", 0x00020005},
+-    {"/redfish/v1/Chassis/SATA_5/Sensors", 0x00020006},
+-    {"/redfish/v1/Chassis/SATA_6/Sensors", 0x00020007},
+-    {"/redfish/v1/Chassis/SATA_7/Sensors", 0x00020008},
+-    {"/redfish/v1/Chassis/SATA_8/Sensors", 0x00020009},
+-    {"/redfish/v1/Chassis/SATA_9/Sensors", 0x0002000a},
+-    {"/redfish/v1/Chassis/SATA_10/Sensors", 0x0002000b},
+-    {"/redfish/v1/Chassis/SATA_11/Sensors", 0x0002000c},
+-    {"/redfish/v1/Chassis/SATA_12/Sensors", 0x0002000d},
+-    {"/redfish/v1/Chassis/SATA_13/Sensors", 0x0002000e},
+-    {"/redfish/v1/Chassis/SATA_14/Sensors", 0x0002000f},
+-    {"/redfish/v1/Chassis/SATA_15/Sensors", 0x00020010},
+-    {"/redfish/v1/Chassis/SATA_16/Sensors", 0x00020011},
+-    {"/redfish/v1/Chassis/SATA_17/Sensors", 0x00020012},
+-    {"/redfish/v1/Chassis/SATA_18/Sensors", 0x00020013},
+-    {"/redfish/v1/Chassis/SATA_19/Sensors", 0x00020014},
+-    {"/redfish/v1/Chassis/SATA_20/Sensors", 0x00020015},
+-    {"/redfish/v1/Chassis/SATA_21/Sensors", 0x00020016},
+-    {"/redfish/v1/Chassis/SATA_22/Sensors", 0x00020017},
+-    {"/redfish/v1/Chassis/SATA_23/Sensors", 0x00020018},
+-    {"/redfish/v1/Chassis/Tray/Sensors/vol_p12v_scaled", 0x00030000},
+-    {"/redfish/v1/Chassis/Tray/Sensors/vol_p5v1_scaled", 0x00030001},
+-    {"/redfish/v1/Chassis/Tray/Sensors/vol_p5v2_scaled", 0x00030002},
+-    {"/redfish/v1/Chassis/Tray/Sensors/vol_p3v3_aux_scaled", 0x00030003},
+-    {"/redfish/v1/Chassis/Tray/Sensors/vol_p1v8_scaled", 0x00030004},
+-    {"/redfish/v1/Chassis/Tray/Sensors/vol_p0v86_scaled", 0x00030005},
+-    {"/redfish/v1/Chassis/Tray/Sensors/vol_p1v45_scaled", 0x00030006},
+-    {"/redfish/v1/Chassis/Tray/Sensors/temp_i2tang", 0x00030007},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_temp", 0x00030008},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_vin", 0x00030009},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_vout", 0x0003000a},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_pin", 0x0003000b},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_iout", 0x0003000c},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_iout", 0x0003000d},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_vin", 0x0003000e},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_temp", 0x0003000f},
+-    {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_pin", 0x00030010},
+-    {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_temp", 0x00030011},
+-    {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_vin", 0x00030012},
+-    {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_vout", 0x00030013},
+-    {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_iout", 0x00030014},
+-    {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_pout", 0x00030015},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_vin", 0x00030016},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_vout", 0x00030017},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_iout", 0x00030018},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_temp", 0x00030019},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_vin", 0x0003001a},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_vout", 0x0003001b},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_iout", 0x0003001c},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_temp", 0x0003001d},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p0v86_vin", 0x0003001e},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p0v86_vout", 0x0003001f},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p0v86_iout", 0x00030020},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p0v86_temp", 0x00030021},
+-    {"/redfish/v1/Chassis/Tray/Sensors/fan0_tach", 0x00030022},
+-    {"/redfish/v1/Chassis/Tray/Sensors/fan1_tach", 0x00030023},
+-    {"/redfish/v1/Chassis/Tray/Sensors/fan0_duty", 0x00030024},
+-    {"/redfish/v1/Chassis/Tray/Sensors/fan1_duty", 0x00030025},
+-    {"/redfish/v1/Chassis/Tray/Sensors/ioc_temp", 0x00030026},
+-    {"/redfish/v1/Chassis/SATA_0/Sensors/Drive_0t", 0x00030027},
+-    {"/redfish/v1/Chassis/SATA_1/Sensors/Drive_0t", 0x00030028},
+-    {"/redfish/v1/Chassis/SATA_2/Sensors/Drive_0t", 0x00030029},
+-    {"/redfish/v1/Chassis/SATA_3/Sensors/Drive_0t", 0x0003002a},
+-    {"/redfish/v1/Chassis/SATA_4/Sensors/Drive_0t", 0x0003002b},
+-    {"/redfish/v1/Chassis/SATA_5/Sensors/Drive_0t", 0x0003002c},
+-    {"/redfish/v1/Chassis/SATA_6/Sensors/Drive_0t", 0x0003002d},
+-    {"/redfish/v1/Chassis/SATA_7/Sensors/Drive_0t", 0x0003002e},
+-    {"/redfish/v1/Chassis/SATA_8/Sensors/Drive_0t", 0x0003002f},
+-    {"/redfish/v1/Chassis/SATA_9/Sensors/Drive_0t", 0x00030030},
+-    {"/redfish/v1/Chassis/SATA_10/Sensors/Drive_0t", 0x00030031},
+-    {"/redfish/v1/Chassis/SATA_11/Sensors/Drive_0t", 0x00030032},
+-    {"/redfish/v1/Chassis/SATA_12/Sensors/Drive_0t", 0x00030033},
+-    {"/redfish/v1/Chassis/SATA_13/Sensors/Drive_0t", 0x00030034},
+-    {"/redfish/v1/Chassis/SATA_14/Sensors/Drive_0t", 0x00030035},
+-    {"/redfish/v1/Chassis/SATA_15/Sensors/Drive_0t", 0x00030036},
+-    {"/redfish/v1/Chassis/SATA_16/Sensors/Drive_0t", 0x00030037},
+-    {"/redfish/v1/Chassis/SATA_17/Sensors/Drive_0t", 0x00030038},
+-    {"/redfish/v1/Chassis/SATA_18/Sensors/Drive_0t", 0x00030039},
+-    {"/redfish/v1/Chassis/SATA_19/Sensors/Drive_0t", 0x0003003a},
+-    {"/redfish/v1/Chassis/SATA_20/Sensors/Drive_0t", 0x0003003b},
+-    {"/redfish/v1/Chassis/SATA_21/Sensors/Drive_0t", 0x0003003c},
+-    {"/redfish/v1/Chassis/SATA_22/Sensors/Drive_0t", 0x0003003d},
+-    {"/redfish/v1/Chassis/SATA_23/Sensors/Drive_0t", 0x0003003e},
+-    {"/redfish/v1/Chassis/Tray/Sensors/host_fan0_pwm", 0x0003003f},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p12v_cem_imon", 0x00030040},
+-    {"/redfish/v1/Chassis/Tray/Sensors/p12v_cem", 0x00030041},
+-    {"/redfish/v1/Chassis/Tray/Sensors/mb_pwr_status", 0x00030042},
+-    {"/redfish/v1/Chassis/Tray/Sensors/fan0_imon", 0x00030043},
+-    {"/redfish/v1/Chassis/Tray/Sensors/fan1_imon", 0x00030044},
+-    {"/redfish/v1/Managers", 0x00040000},
+-    {"/redfish/v1/Managers/mbmc", 0x00050000},
+-    {"/redfish/v1/Chassis/SATA_0/Drives", 0x00060001},
+-    {"/redfish/v1/Chassis/SATA_1/Drives", 0x00060002},
+-    {"/redfish/v1/Chassis/SATA_2/Drives", 0x00060003},
+-    {"/redfish/v1/Chassis/SATA_3/Drives", 0x00060004},
+-    {"/redfish/v1/Chassis/SATA_4/Drives", 0x00060005},
+-    {"/redfish/v1/Chassis/SATA_5/Drives", 0x00060006},
+-    {"/redfish/v1/Chassis/SATA_6/Drives", 0x00060007},
+-    {"/redfish/v1/Chassis/SATA_7/Drives", 0x00060008},
+-    {"/redfish/v1/Chassis/SATA_8/Drives", 0x00060009},
+-    {"/redfish/v1/Chassis/SATA_9/Drives", 0x0006000a},
+-    {"/redfish/v1/Chassis/SATA_10/Drives", 0x0006000b},
+-    {"/redfish/v1/Chassis/SATA_11/Drives", 0x0006000c},
+-    {"/redfish/v1/Chassis/SATA_12/Drives", 0x0006000d},
+-    {"/redfish/v1/Chassis/SATA_13/Drives", 0x0006000e},
+-    {"/redfish/v1/Chassis/SATA_14/Drives", 0x0006000f},
+-    {"/redfish/v1/Chassis/SATA_15/Drives", 0x00060010},
+-    {"/redfish/v1/Chassis/SATA_16/Drives", 0x00060011},
+-    {"/redfish/v1/Chassis/SATA_17/Drives", 0x00060012},
+-    {"/redfish/v1/Chassis/SATA_18/Drives", 0x00060013},
+-    {"/redfish/v1/Chassis/SATA_19/Drives", 0x00060014},
+-    {"/redfish/v1/Chassis/SATA_20/Drives", 0x00060015},
+-    {"/redfish/v1/Chassis/SATA_21/Drives", 0x00060016},
+-    {"/redfish/v1/Chassis/SATA_22/Drives", 0x00060017},
+-    {"/redfish/v1/Chassis/SATA_23/Drives", 0x00060018},
+-    {"/redfish/v1/Chassis/SATA_0/Drives/SATA_0", 0x00070000},
+-    {"/redfish/v1/Chassis/SATA_1/Drives/SATA_1", 0x00070001},
+-    {"/redfish/v1/Chassis/SATA_2/Drives/SATA_2", 0x00070002},
+-    {"/redfish/v1/Chassis/SATA_3/Drives/SATA_3", 0x00070003},
+-    {"/redfish/v1/Chassis/SATA_4/Drives/SATA_4", 0x00070004},
+-    {"/redfish/v1/Chassis/SATA_5/Drives/SATA_5", 0x00070005},
+-    {"/redfish/v1/Chassis/SATA_6/Drives/SATA_6", 0x00070006},
+-    {"/redfish/v1/Chassis/SATA_7/Drives/SATA_7", 0x00070007},
+-    {"/redfish/v1/Chassis/SATA_8/Drives/SATA_8", 0x00070008},
+-    {"/redfish/v1/Chassis/SATA_9/Drives/SATA_9", 0x00070009},
+-    {"/redfish/v1/Chassis/SATA_10/Drives/SATA_10", 0x0007000a},
+-    {"/redfish/v1/Chassis/SATA_11/Drives/SATA_11", 0x0007000b},
+-    {"/redfish/v1/Chassis/SATA_12/Drives/SATA_12", 0x0007000c},
+-    {"/redfish/v1/Chassis/SATA_13/Drives/SATA_13", 0x0007000d},
+-    {"/redfish/v1/Chassis/SATA_14/Drives/SATA_14", 0x0007000e},
+-    {"/redfish/v1/Chassis/SATA_15/Drives/SATA_15", 0x0007000f},
+-    {"/redfish/v1/Chassis/SATA_16/Drives/SATA_16", 0x00070010},
+-    {"/redfish/v1/Chassis/SATA_17/Drives/SATA_17", 0x00070011},
+-    {"/redfish/v1/Chassis/SATA_18/Drives/SATA_18", 0x00070012},
+-    {"/redfish/v1/Chassis/SATA_19/Drives/SATA_19", 0x00070013},
+-    {"/redfish/v1/Chassis/SATA_20/Drives/SATA_20", 0x00070014},
+-    {"/redfish/v1/Chassis/SATA_21/Drives/SATA_21", 0x00070015},
+-    {"/redfish/v1/Chassis/SATA_22/Drives/SATA_22", 0x00070016},
+-    {"/redfish/v1/Chassis/SATA_23/Drives/SATA_23", 0x00070017},
+-    {"/redfish/v1/UpdateService", 0x00080000},
+-    {"/redfish/v1/UpdateService/FirmwareInventory", 0x000a0000},
+-    {"/redfish/v1/UpdateService/FirmwareInventory/mbmc", 0x00090000},
+-    {"/redfish/v1/Chassis/Tray/Controls", 0x000c0000},
+-    {"/redfish/v1/Chassis/Tray/Controls/bmc_pid", 0x000b0000},
+-    {"/redfish/v1/Chassis/Tray/Controls/lat_pid", 0x000b0001},
+-    {"/redfish/v1/Chassis/Tray/Controls/ioc_pid", 0x000b0002},
+-    {"/redfish/v1/Chassis/Tray/Controls/vr_pid", 0x000b0003},
+-    {"/redfish/v1/Chassis/Tray/Controls/powerbrick_pid", 0x000b0004},
+-    {"/redfish/v1/Chassis/Tray/Controls/hdd_max_pid", 0x000b0005},
+-    {"/redfish/v1/Chassis/Tray/Controls/hdd_avg_pid", 0x000b0006},
+-    {"/redfish/v1/Chassis/Tray/Controls/fans", 0x000b0007},
+-    {"/redfish/v1/Storage", 0x000d0000},
+-    {"/redfish/v1/Storage/SATA", 0x000e0000},
+-    {"/redfish/v1/Storage/SATA/Controllers", 0x000f0000},
+-    {"/redfish/v1/Storage/SATA/Controllers/ioc", 0x00100000},
+-    {"/redfish/v1/Managers/mbmc/ManagerDiagnosticData", 0x00110000}
+-};
+-
+-int getResourceIdForUri(std::string_view uri, uint32_t& resourceId)
+-{
+-    auto it = resourceIdMap.find(uri);
+-    if (it != resourceIdMap.end())
+-    {
+-        resourceId = it->second;
+-        if (DEBUG)
+-        {
+-            std::cout << "Resource id found: " << std::to_string(it->second)
+-                      << "\n";
+-        }
+-        return 0;
+-    }
+-    if ((uri.find("Cables") == std::string::npos) &&
+-        (uri.find("Systems") == std::string::npos))
+-    {
+-        std::cerr << "Resource id not found for uri: " << uri << std::endl;
+-    }
+-    return 1;
+-}
+diff --git a/rded/meson.build b/rded/meson.build
+index ca2b087..ae622d5 100644
+--- a/rded/meson.build
++++ b/rded/meson.build
+@@ -2,6 +2,7 @@ sources = [
+   'rded.cpp',
+   'helper/discovery/base_discovery.cpp',
+   'helper/discovery/rde_discovery.cpp',
++  'helper/discovery/platform_discovery.cpp',
+   'helper/rde_operation/rde_operation.cpp',
+   'helper/rde_operation/rde_update_utils.cpp'
+ ]
+diff --git a/rded/rded.cpp b/rded/rded.cpp
+index ecd83d0..bc367dc 100644
+--- a/rded/rded.cpp
++++ b/rded/rded.cpp
+@@ -1,16 +1,16 @@
+ #include "common/utils.hpp"
+ #include "helper/common.hpp"
+ #include "helper/discovery/base_discovery.hpp"
++#include "helper/discovery/platform_discovery.hpp"
+ #include "helper/discovery/rde_discovery.hpp"
+ #include "helper/rde_operation/rde_operation.hpp"
+-#include "helper/resource_id_mapper.hpp"
+ 
+ // libbej
+ #include "libbej/bej_common.h"
+ #include "libbej/bej_encoder_core.h"
+ 
+ #include "libbej/bej_encoder_json.hpp"
+-#include <csignal>
++
+ #include <locale.h>
+ #include <signal.h>
+ #include <string.h>
+@@ -29,6 +29,7 @@
+ #include <sdbusplus/unpack_properties.hpp>
+ #include <sdeventplus/event.hpp>
+ 
++#include <csignal>
+ #include <cstddef>
+ #include <iostream>
+ #include <unordered_map>
+@@ -60,11 +61,41 @@ std::unordered_map<std::string,
+     dbusIntfMap;
+ std::unordered_map<std::string, std::string> objectPathDeviceId;
+ 
++std::unordered_map<std::string, std::unordered_map<std::string, uint32_t>>
++    rdeResourceIdMap;
++
++static int getResourceIdForUri(std::string& uri, std::string& udevId,
++                               uint32_t& resourceId)
++{
++    if (rdeResourceIdMap.find(udevId) != rdeResourceIdMap.end())
++    {
++        std::unordered_map<std::string, uint32_t>::iterator it =
++            rdeResourceIdMap[udevId].find(uri);
++        if (it != rdeResourceIdMap[udevId].end())
++        {
++            resourceId = it->second;
++            if (DEBUG)
++            {
++                std::cout << "Resource id found: " << std::to_string(it->second)
++                          << "\n";
++            }
++            return 0;
++        }
++    }
++
++    if ((uri.find("Cables") == std::string::npos) &&
++        (uri.find("Systems") == std::string::npos))
++    {
++        std::cerr << "Resource id not found for uri: " << uri << std::endl;
++    }
++    return 1;
++}
++
+ void cleanupAtExit()
+ {
+     // cleans up at daemon termination
+     fd = 0;
+-    resourceIdMap.clear();
++    rdeResourceIdMap.clear();
+     deviceNetIdMap.clear();
+     dbusIntfMap.clear();
+     objectPathDeviceId.clear();
+@@ -74,7 +105,8 @@ void cleanupAtExit()
+     cleanupMctpAtExit();
+ }
+ 
+-void signalHandler(int signal) {
++void signalHandler(int signal)
++{
+     std::cerr << "Received signal " << signal << ". Cleaning up...\n";
+     cleanupAtExit();
+     std::exit(signal);
+@@ -96,7 +128,30 @@ int initiateDiscovery(int fd, std::string udevId, int netId, uint8_t destEid,
+     }
+ 
+     std::cerr << "Initializing RDE Discovery...\n";
+-    rc = performRdeDiscovery(udevId, fd, netId, destEid, instanceId);
++    uint32_t negotiatedTransferSize = 0;
++    rc = performRdeDiscovery(udevId, fd, netId, destEid, instanceId,
++                             negotiatedTransferSize);
++
++    if (rc)
++    {
++        std::cerr << "Failure in Base Discovery with error code: " << rc
++                  << "\n";
++        return rc;
++    }
++
++    std::unordered_map<std::string, uint32_t> resourceIdMap;
++    rdeResourceIdMap.emplace(std::make_pair(udevId, std::move(resourceIdMap)));
++    auto it = rdeResourceIdMap.find(udevId);
++    if (it == rdeResourceIdMap.end())
++    {
++        std::cerr << "Failed to find Resource ID map for " << udevId
++                  << " device" << std::endl;
++        return -1;
++    }
++
++    std::cerr << "Initializing PDR Discovery...\n";
++    rc = performPdrDiscovery(udevId, fd, netId, destEid, instanceId,
++                             negotiatedTransferSize, it->second);
+ 
+     if (rc)
+     {
+@@ -105,7 +160,8 @@ int initiateDiscovery(int fd, std::string udevId, int netId, uint8_t destEid,
+         return rc;
+     }
+ 
+-    rc = performDictionaryDiscoveryForDevice(udevId, fd, destEid, instanceId);
++    rc = performDictionaryDiscoveryForDevice(udevId, fd, destEid, instanceId,
++                                             it->second);
+ 
+     if (rc)
+     {
+@@ -310,7 +366,7 @@ std::string
+     }
+     truncateTrailingFwSlash(uri);
+ 
+-    rc = getResourceIdForUri(uri, resourceId);
++    rc = getResourceIdForUri(uri, udevid, resourceId);
+     if (rc)
+     {
+         // TODO(@harshtya) - Define operation Types to be GET or POST
+@@ -336,7 +392,7 @@ std::string
+ 
+         if (isActionOperation(uri, resource_uri))
+         {
+-            rc = getResourceIdForUri(resource_uri, resourceId);
++            rc = getResourceIdForUri(resource_uri, udevid, resourceId);
+             if (rc)
+             {
+                 std::cerr
+@@ -654,6 +710,8 @@ int triggerRdeReactor(int fd)
+             {
+                 cleanupDictionaries(deviceId);
+                 cleanupMctpLink(deviceId);
++                // Remove the resource ID maps for the rde device
++                rdeResourceIdMap.erase(deviceId);
+             }
+             // TODO (@harshtya): clean up the manager for this object path
+             // TODO (@harshtya): clean up the dictionaries
+-- 
+2.47.0.277.g8800431eea-goog
+
diff --git a/recipes-phosphor/pldm/pldm_%.bbappend b/recipes-phosphor/pldm/pldm_%.bbappend
index af23030..9ae0cb4 100644
--- a/recipes-phosphor/pldm/pldm_%.bbappend
+++ b/recipes-phosphor/pldm/pldm_%.bbappend
@@ -22,6 +22,7 @@
     file://0012-Update-rde-resource-map.patch \
     file://0013-Use-Rde-Op-Enumerate-to-recover-BMC-RDE-device-commu.patch \
     file://0014-rded-support-redfish-expand-feature-for-RDE-Devices.patch \
+    file://0015-Add-Redfish-PDR-support.patch \
 "