diff --git a/host_pdr_handler.cpp b/host_pdr_handler.cpp
index c627b0b..389a492 100644
--- a/host_pdr_handler.cpp
+++ b/host_pdr_handler.cpp
@@ -2,6 +2,8 @@
 
 #include "host_pdr_handler.hpp"
 
+#include <assert.h>
+
 #include <fstream>
 #include <nlohmann/json.hpp>
 
@@ -27,6 +29,8 @@
     fs::path hostFruJson(fs::path(HOST_JSONS_DIR) / fruJson);
     if (fs::exists(hostFruJson))
     {
+        // Note parent entities for entities sent down by the host firmware.
+        // This will enable a merge of entity associations.
         try
         {
             std::ifstream jsonFile(hostFruJson);
@@ -77,6 +81,7 @@
     std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
                                     PLDM_GET_PDR_REQ_BYTES);
     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+    bool merged = false;
 
     for (auto recordHandle : pdrRecordHandles)
     {
@@ -108,14 +113,14 @@
             return;
         }
 
-        auto responsePtr =
-            reinterpret_cast<struct pldm_msg*>(responseMsgPtr.get());
         uint8_t completionCode{};
         uint32_t nextRecordHandle{};
         uint32_t nextDataTransferHandle{};
         uint8_t transferFlag{};
         uint16_t respCount{};
         uint8_t transferCRC{};
+        auto responsePtr =
+            reinterpret_cast<struct pldm_msg*>(responseMsgPtr.get());
         rc = decode_get_pdr_resp(
             responsePtr, responseMsgSize - sizeof(pldm_msg_hdr),
             &completionCode, &nextRecordHandle, &nextDataTransferHandle,
@@ -141,10 +146,13 @@
             }
             else
             {
+                // Process the PDR host firmware sent us. The most common action
+                // is to add the PDR to the the BMC's PDR repo.
                 auto pdrHdr = reinterpret_cast<pldm_pdr_hdr*>(pdr.data());
                 if (pdrHdr->type == PLDM_PDR_ENTITY_ASSOCIATION)
                 {
                     mergeEntityAssociations(pdr);
+                    merged = true;
                 }
                 else
                 {
@@ -153,6 +161,15 @@
             }
         }
     }
+
+    if (merged)
+    {
+        // We have merged host's entity association PDRs with our own. Send an
+        // event to the host firmware to indicate the same.
+        sendPDRRepositoryChgEvent(
+            std::move(std::vector<uint8_t>(1, PLDM_PDR_ENTITY_ASSOCIATION)),
+            FORMAT_IS_PDR_HANDLES);
+    }
 }
 
 bool HostPDRHandler::getParent(EntityType type, pldm_entity& parent)
@@ -196,8 +213,106 @@
 
     if (merged)
     {
+        // Update our PDR repo with the merged entity association PDRs
         pldm_entity_association_pdr_add(entityTree, repo, true);
     }
 }
 
+void HostPDRHandler::sendPDRRepositoryChgEvent(std::vector<uint8_t>&& pdrTypes,
+                                               uint8_t eventDataFormat)
+{
+    assert(eventDataFormat == FORMAT_IS_PDR_HANDLES);
+
+    // Extract from the PDR repo record handles of PDRs we want the host
+    // to pull up.
+    std::vector<uint8_t> eventDataOps{PLDM_RECORDS_ADDED};
+    std::vector<uint8_t> numsOfChangeEntries(1);
+    std::vector<std::vector<ChangeEntry>> changeEntries(
+        numsOfChangeEntries.size());
+    for (auto pdrType : pdrTypes)
+    {
+        const pldm_pdr_record* record{};
+        do
+        {
+            record = pldm_pdr_find_record_by_type(repo, pdrType, record,
+                                                  nullptr, nullptr);
+            if (record && pldm_pdr_record_is_remote(record))
+            {
+                changeEntries[0].push_back(
+                    pldm_pdr_get_record_handle(repo, record));
+            }
+        } while (record);
+    }
+    if (changeEntries.empty())
+    {
+        return;
+    }
+    numsOfChangeEntries[0] = changeEntries[0].size();
+
+    // Encode PLDM platform event msg to indicate a PDR repo change.
+    size_t maxSize = PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH +
+                     PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH +
+                     changeEntries[0].size() * sizeof(uint32_t);
+    std::vector<uint8_t> eventDataVec{};
+    eventDataVec.resize(maxSize);
+    auto eventData =
+        reinterpret_cast<struct pldm_pdr_repository_chg_event_data*>(
+            eventDataVec.data());
+    size_t actualSize{};
+    auto firstEntry = changeEntries[0].data();
+    auto rc = encode_pldm_pdr_repository_chg_event_data(
+        eventDataFormat, 1, eventDataOps.data(), numsOfChangeEntries.data(),
+        &firstEntry, eventData, &actualSize, maxSize);
+    if (rc != PLDM_SUCCESS)
+    {
+        std::cerr
+            << "Failed to encode_pldm_pdr_repository_chg_event_data, rc = "
+            << rc << std::endl;
+        return;
+    }
+    auto instanceId = requester.getInstanceId(mctp_eid);
+    std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
+                                    PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
+                                    actualSize);
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+    rc = encode_platform_event_message_req(
+        instanceId, 1, 0, PLDM_PDR_REPOSITORY_CHG_EVENT, eventDataVec.data(),
+        actualSize, request);
+    if (rc != PLDM_SUCCESS)
+    {
+        requester.markFree(mctp_eid, instanceId);
+        std::cerr << "Failed to encode_platform_event_message_req, rc = " << rc
+                  << std::endl;
+        return;
+    }
+
+    // Send up the event to host.
+    uint8_t* responseMsg = nullptr;
+    size_t responseMsgSize{};
+    auto requesterRc =
+        pldm_send_recv(mctp_eid, mctp_fd, requestMsg.data(), requestMsg.size(),
+                       &responseMsg, &responseMsgSize);
+    requester.markFree(mctp_eid, instanceId);
+    if (requesterRc != PLDM_REQUESTER_SUCCESS)
+    {
+        std::cerr << "Failed to send msg to report pdrs, rc = " << requesterRc
+                  << std::endl;
+        return;
+    }
+    uint8_t completionCode{};
+    uint8_t status{};
+    auto responsePtr = reinterpret_cast<struct pldm_msg*>(responseMsg);
+    rc = decode_platform_event_message_resp(
+        responsePtr, responseMsgSize - sizeof(pldm_msg_hdr), &completionCode,
+        &status);
+    free(responseMsg);
+    if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
+    {
+        std::cerr << "Failed to decode_platform_event_message_resp: "
+                  << "rc=" << rc
+                  << ", cc=" << static_cast<unsigned>(completionCode)
+                  << std::endl;
+    }
+}
+
 } // namespace pldm
diff --git a/host_pdr_handler.hpp b/host_pdr_handler.hpp
index af1fbab..fec6da6 100644
--- a/host_pdr_handler.hpp
+++ b/host_pdr_handler.hpp
@@ -59,8 +59,18 @@
      *  @param[in] recordHandles - list of record handles pointing to host's
      *             PDRs that need to be fetched.
      */
+
     void fetchPDR(std::vector<uint32_t>&& recordHandles);
 
+    /** @brief Send a PLDM event to host firmware containing a list of record
+     *  handles of PDRs that the host firmware has to fetch.
+     *  @param[in] pdrTypes - list of PDR types that need to be looked up in the
+     *                        BMC repo
+     *  @param[in] eventDataFormat - format for PDRRepositoryChgEvent in DSP0248
+     */
+    void sendPDRRepositoryChgEvent(std::vector<uint8_t>&& pdrTypes,
+                                   uint8_t eventDataFormat);
+
   private:
     /** @brief fetchPDR schedules work on the event loop, this method does the
      *  actual work. This is so that the PDR exchg with the host is async.
diff --git a/libpldm/pdr.c b/libpldm/pdr.c
index 64c314b..e0cd527 100644
--- a/libpldm/pdr.c
+++ b/libpldm/pdr.c
@@ -195,8 +195,6 @@
 			     uint32_t *size)
 {
 	assert(repo != NULL);
-	assert(data != NULL);
-	assert(size != NULL);
 
 	pldm_pdr_record *record = repo->first;
 	if (curr_record != NULL) {
@@ -205,14 +203,18 @@
 	while (record != NULL) {
 		struct pldm_pdr_hdr *hdr = (struct pldm_pdr_hdr *)record->data;
 		if (hdr->type == pdr_type) {
-			*size = record->size;
-			*data = record->data;
+			if (data && size) {
+				*size = record->size;
+				*data = record->data;
+			}
 			return record;
 		}
 		record = record->next;
 	}
 
-	*size = 0;
+	if (size) {
+		*size = 0;
+	}
 	return NULL;
 }
 
diff --git a/libpldm/pdr.h b/libpldm/pdr.h
index 16ceb55..b85bed5 100644
--- a/libpldm/pdr.h
+++ b/libpldm/pdr.h
@@ -125,8 +125,8 @@
  *  @param[in] curr_record - opaque pointer acting as a PDR record handle; if
  *  not NULL, then search will begin from this record's next record
  *  @param[in/out] data - will point to PDR record data (as per DSP0248) on
- *                        return
- *  @param[out] size - *size will be size of PDR record
+ *                        return, if input is not NULL
+ *  @param[out] size - *size will be size of PDR record, if input is not NULL
  *
  *  @return opaque pointer acting as PDR record handle, will be NULL if record
  *  was not found
diff --git a/libpldmresponder/fru_parser.cpp b/libpldmresponder/fru_parser.cpp
index e2c2317..a2e2e92 100644
--- a/libpldmresponder/fru_parser.cpp
+++ b/libpldmresponder/fru_parser.cpp
@@ -94,45 +94,54 @@
             throw InternalFailure();
         }
 
-        auto record = data.value("record_details", emptyJson);
-        auto recordType =
-            static_cast<uint8_t>(record.value("fru_record_type", 0));
-        auto encType =
-            static_cast<uint8_t>(record.value("fru_encoding_type", 0));
-        auto dbusIntfName = record.value("dbus_interface_name", "");
-        auto entries = data.value("fru_fields", emptyJsonList);
-        std::vector<FieldInfo> fieldInfo;
-
-        for (const auto& entry : entries)
+        try
         {
-            auto fieldType =
-                static_cast<uint8_t>(entry.value("fru_field_type", 0));
-            auto dbus = entry.value("dbus", emptyJson);
-            auto interface = dbus.value("interface", "");
-            auto property = dbus.value("property_name", "");
-            auto propType = dbus.value("property_type", "");
-            fieldInfo.emplace_back(
-                std::make_tuple(std::move(interface), std::move(property),
-                                std::move(propType), std::move(fieldType)));
+            auto record = data.value("record_details", emptyJson);
+            auto recordType =
+                static_cast<uint8_t>(record.value("fru_record_type", 0));
+            auto encType =
+                static_cast<uint8_t>(record.value("fru_encoding_type", 0));
+            auto dbusIntfName = record.value("dbus_interface_name", "");
+            auto entries = data.value("fru_fields", emptyJsonList);
+            std::vector<FieldInfo> fieldInfo;
+
+            for (const auto& entry : entries)
+            {
+                auto fieldType =
+                    static_cast<uint8_t>(entry.value("fru_field_type", 0));
+                auto dbus = entry.value("dbus", emptyJson);
+                auto interface = dbus.value("interface", "");
+                auto property = dbus.value("property_name", "");
+                auto propType = dbus.value("property_type", "");
+                fieldInfo.emplace_back(
+                    std::make_tuple(std::move(interface), std::move(property),
+                                    std::move(propType), std::move(fieldType)));
+            }
+
+            FruRecordInfo fruInfo;
+            fruInfo =
+                std::make_tuple(recordType, encType, std::move(fieldInfo));
+
+            auto search = recordMap.find(dbusIntfName);
+
+            // PLDM FRU can have multiple records for the same FRU like General
+            // FRU record and multiple OEM FRU records. If the FRU item
+            // interface name is already in the map, that indicates a record
+            // info is already added for the FRU, so append the new record info
+            // to the same data.
+            if (search != recordMap.end())
+            {
+                search->second.emplace_back(std::move(fruInfo));
+            }
+            else
+            {
+                FruRecordInfos recordInfos{fruInfo};
+                recordMap.emplace(dbusIntfName, recordInfos);
+            }
         }
-
-        FruRecordInfo fruInfo;
-        fruInfo = std::make_tuple(recordType, encType, std::move(fieldInfo));
-
-        auto search = recordMap.find(dbusIntfName);
-
-        // PLDM FRU can have multiple records for the same FRU like General FRU
-        // record and multiple OEM FRU records. If the FRU item interface name
-        // is already in the map, that indicates a record info is already added
-        // for the FRU, so append the new record info to the same data.
-        if (search != recordMap.end())
+        catch (const std::exception& e)
         {
-            search->second.emplace_back(std::move(fruInfo));
-        }
-        else
-        {
-            FruRecordInfos recordInfos{fruInfo};
-            recordMap.emplace(dbusIntfName, recordInfos);
+            continue;
         }
     }
 }
diff --git a/tool/pldm_platform_cmd.cpp b/tool/pldm_platform_cmd.cpp
index 387f03f..db5cbed 100644
--- a/tool/pldm_platform_cmd.cpp
+++ b/tool/pldm_platform_cmd.cpp
@@ -82,6 +82,8 @@
   private:
     const std::map<uint16_t, std::string> entityType = {
         {64, "System Board"},
+        {66, "Memory Module"},
+        {67, "Processor Module"},
         {137, "Management Controller"},
         {69, "Chassis front panel board (control panel)"},
         {123, "Power converter"},