diff --git a/oem/ampere/event/oem_event_manager.cpp b/oem/ampere/event/oem_event_manager.cpp
index 9f52756..1aae241 100644
--- a/oem/ampere/event/oem_event_manager.cpp
+++ b/oem/ampere/event/oem_event_manager.cpp
@@ -22,6 +22,11 @@
 namespace oem_ampere
 {
 namespace boot_stage = boot::stage;
+namespace ddr_status = ddr::status;
+namespace dimm_status = dimm::status;
+namespace dimm_syndrome = dimm::training_failure::dimm_syndrome;
+namespace phy_syndrome = dimm::training_failure::phy_syndrome;
+namespace training_failure = dimm::training_failure;
 
 constexpr const char* ampereEventRegistry = "OpenBMC.0.1.AmpereEvent.OK";
 constexpr const char* ampereWarningRegistry =
@@ -31,6 +36,7 @@
 constexpr const char* BIOSFWPanicRegistry =
     "OpenBMC.0.1.BIOSFirmwarePanicReason.Warning";
 constexpr auto maxDIMMIdxBitNum = 24;
+constexpr auto maxDIMMInstantNum = 24;
 
 /*
     An array of possible boot status of a boot stage.
@@ -46,6 +52,13 @@
     " progress started", " in-progress", " progress completed"};
 
 /*
+    A map between PMIC status and logging strings.
+*/
+std::array<std::string, 8> pmicTempAlertMsg = {
+    "Below 85°C", "85°C",  "95°C",  "105°C",
+    "115°C",      "125°C", "135°C", "Equal or greater than 140°C"};
+
+/*
     In Ampere systems, BMC only directly communicates with MCTP/PLDM SoC
     EPs through SMBus and PCIe. When host boots up, SMBUS interface
     comes up first. In this interface, BMC is bus owner.
@@ -59,7 +72,8 @@
     A map between sensor IDs and their names in string.
     Using pldm::oem::sensor_ids
 */
-EventToMsgMap_t sensorIdToStrMap = {{PCIE_HOT_PLUG, "PCIE_HOT_PLUG"},
+EventToMsgMap_t sensorIdToStrMap = {{DDR_STATUS, "DDR_STATUS"},
+                                    {PCIE_HOT_PLUG, "PCIE_HOT_PLUG"},
                                     {BOOT_OVERALL, "BOOT_OVERALL"}};
 
 /*
@@ -81,6 +95,77 @@
      "ATF BL33 (UEFI) booting status = "}};
 
 /*
+    A map between DDR status and logging strings.
+    Using pldm::oem::ddr::status::ddr_status
+*/
+EventToMsgMap_t ddrStatusToMsgMap = {
+    {ddr_status::NO_SYSTEM_LEVEL_ERROR, "has no system level error"},
+    {ddr_status::ECC_INITIALIZATION_FAILURE, "has ECC initialization failure"},
+    {ddr_status::CONFIGURATION_FAILURE, "has configuration failure at DIMMs:"},
+    {ddr_status::TRAINING_FAILURE, "has training failure at DIMMs:"},
+    {ddr_status::OTHER_FAILURE, "has other failure"},
+    {ddr_status::BOOT_FAILURE_NO_VALID_CONFIG,
+     "has boot failure due to no configuration"},
+    {ddr_status::FAILSAFE_ACTIVATED_NEXT_BOOT_SUCCESS,
+     "failsafe activated but boot success with the next valid configuration"}};
+
+/*
+    A map between DIMM status and logging strings.
+    Using pldm::oem::dimm::status::dimm_status
+*/
+EventToMsgMap_t dimmStatusToMsgMap = {
+    {dimm_status::INSTALLED_NO_ERROR, "is installed and no error"},
+    {dimm_status::NOT_INSTALLED, "is not installed"},
+    {dimm_status::OTHER_FAILURE, "has other failure"},
+    {dimm_status::INSTALLED_BUT_DISABLED, "is installed but disabled"},
+    {dimm_status::TRAINING_FAILURE, "has training failure; "},
+    {dimm_status::PMIC_TEMP_ALERT, "has PMIC temperature alert"}};
+
+/*
+    A map between PHY training failure syndrome and logging strings.
+    Using
+   pldm::oem::dimm::training_faillure::phy_syndrome::phy_training_failure_syndrome
+*/
+EventToMsgMap_t phyTrainingFailureSyndromeToMsgMap = {
+    {phy_syndrome::NA, "(N/A)"},
+    {phy_syndrome::PHY_TRAINING_SETUP_FAILURE, "(PHY training setup failure)"},
+    {phy_syndrome::CA_LEVELING, "(CA leveling)"},
+    {phy_syndrome::PHY_WRITE_LEVEL_FAILURE,
+     "(PHY write level failure - see syndrome 1)"},
+    {phy_syndrome::PHY_READ_GATE_LEVELING_FAILURE,
+     "(PHY read gate leveling failure)"},
+    {phy_syndrome::PHY_READ_LEVEL_FAILURE, "(PHY read level failure)"},
+    {phy_syndrome::WRITE_DQ_LEVELING, "(Write DQ leveling)"},
+    {phy_syndrome::PHY_SW_TRAINING_FAILURE, "(PHY SW training failure)"}};
+
+/*
+    A map between DIMM training failure syndrome and logging strings.
+    Using
+   pldm::oem::dimm::training_faillure::dimm_syndrome::dimm_training_failure_syndrome
+*/
+EventToMsgMap_t dimmTrainingFailureSyndromeToMsgMap = {
+    {dimm_syndrome::NA, "(N/A)"},
+    {dimm_syndrome::DRAM_VREFDQ_TRAINING_FAILURE,
+     "(DRAM VREFDQ training failure)"},
+    {dimm_syndrome::LRDIMM_DB_TRAINING_FAILURE, "(LRDIMM DB training failure)"},
+    {dimm_syndrome::LRDRIMM_DB_SW_TRAINING_FAILURE,
+     "(LRDRIMM DB SW training failure)"}};
+
+/*
+    A map between DIMM training failure type and a pair of <logging strings -
+   syndrome map>. Using
+   pldm::oem::dimm::training_faillure::dimm_training_failure_type
+*/
+std::unordered_map<uint8_t, std::pair<std::string, EventToMsgMap_t>>
+    dimmTrainingFailureTypeMap = {
+        {training_failure::PHY_TRAINING_FAILURE_TYPE,
+         std::make_pair("PHY training failure",
+                        phyTrainingFailureSyndromeToMsgMap)},
+        {training_failure::DIMM_TRAINING_FAILURE_TYPE,
+         std::make_pair("DIMM training failure",
+                        dimmTrainingFailureSyndromeToMsgMap)}};
+
+/*
     A map between log level and the registry used for Redfish SEL log
     Using pldm::oem::log_level
 */
@@ -259,6 +344,14 @@
         return rc;
     }
 
+    // DIMMx_Status sensorID 4+2*index (index 0 -> maxDIMMInstantNum-1)
+    if (auto dimmIdx = (sensorId - 4) / 2;
+        sensorId >= 4 && dimmIdx >= 0 && dimmIdx < maxDIMMInstantNum)
+    {
+        handleDIMMStatusEvent(tid, sensorId, presentReading);
+        return PLDM_SUCCESS;
+    }
+
     switch (sensorId)
     {
         case BOOT_OVERALL:
@@ -267,6 +360,9 @@
         case PCIE_HOT_PLUG:
             handlePCIeHotPlugEvent(tid, sensorId, presentReading);
             break;
+        case DDR_STATUS:
+            handleDDRStatusEvent(tid, sensorId, presentReading);
+            break;
         default:
             std::string description;
             std::stringstream strStream;
@@ -465,5 +561,168 @@
     sendJournalRedfish(description, logLevel);
 }
 
+std::string OemEventManager::dimmTrainingFailureToMsg(uint32_t failureInfo)
+{
+    std::string description;
+    DIMMTrainingFailure_t failure{failureInfo};
+
+    if (dimmTrainingFailureTypeMap.contains(failure.bits.type))
+    {
+        auto failureInfoMap = dimmTrainingFailureTypeMap[failure.bits.type];
+
+        description += std::get<0>(failureInfoMap);
+
+        description += "; MCU rank index " +
+                       std::to_string(failure.bits.mcuRankIdx);
+
+        description += "; Slice number " +
+                       std::to_string(failure.bits.sliceNum);
+
+        description += "; Upper nibble error status: ";
+        description += (!failure.bits.upperNibbStatErr)
+                           ? "No error"
+                           : "Found no rising edge";
+
+        description += "; Lower nibble error status: ";
+        description += (!failure.bits.lowerNibbStatErr)
+                           ? "No error"
+                           : "Found no rising edge";
+
+        description += "; Failure syndrome 0: ";
+
+        auto& syndromeMap = std::get<1>(failureInfoMap);
+        if (syndromeMap.contains(failure.bits.syndrome))
+        {
+            description += syndromeMap[failure.bits.syndrome];
+        }
+        else
+        {
+            description += "(Unknown syndrome)";
+        }
+    }
+    else
+    {
+        description += "Unknown training failure type " +
+                       std::to_string(failure.bits.type);
+    }
+
+    return description;
+}
+
+void OemEventManager::handleDIMMStatusEvent(pldm_tid_t tid, uint16_t sensorId,
+                                            uint32_t presentReading)
+{
+    log_level logLevel{log_level::WARNING};
+    std::string description;
+    uint8_t byte3 = (presentReading & 0xff000000) >> 24;
+    uint32_t byte012 = presentReading & 0xffffff;
+
+    description += prefixMsgStrCreation(tid, sensorId);
+
+    uint8_t dimmIdx = (sensorId - 4) / 2;
+
+    description += "DIMM " + std::to_string(dimmIdx) + " ";
+
+    if (dimmStatusToMsgMap.contains(byte3))
+    {
+        if (byte3 == dimm_status::INSTALLED_NO_ERROR ||
+            byte3 == dimm_status::INSTALLED_BUT_DISABLED)
+        {
+            logLevel = log_level::OK;
+        }
+
+        description += dimmStatusToMsgMap[byte3];
+
+        if (byte3 == dimm_status::TRAINING_FAILURE)
+        {
+            description += "; " + dimmTrainingFailureToMsg(byte012);
+        }
+        else if (byte3 == dimm_status::PMIC_TEMP_ALERT)
+        {
+            uint8_t byte0 = (byte012 & 0xff);
+            if (byte0 < pmicTempAlertMsg.size())
+            {
+                description += ": " + pmicTempAlertMsg[byte0];
+            }
+        }
+    }
+    else
+    {
+        switch (byte3)
+        {
+            case dimm_status::PMIC_HIGH_TEMP:
+                if (byte012 == 0x01)
+                {
+                    description += "has PMIC high temp condition";
+                }
+                break;
+            case dimm_status::TSx_HIGH_TEMP:
+                switch (byte012)
+                {
+                    case 0x01:
+                        description += "has TS0";
+                        break;
+                    case 0x02:
+                        description += "has TS1";
+                        break;
+                    case 0x03:
+                        description += "has TS0 and TS1";
+                        break;
+                }
+                description += " exceeding their high temperature threshold";
+                break;
+            case dimm_status::SPD_HUB_HIGH_TEMP:
+                if (byte012 == 0x01)
+                {
+                    description += "has SPD/HUB high temp condition";
+                }
+                break;
+            default:
+                description += "has unsupported status " +
+                               std::to_string(byte3);
+                break;
+        }
+    }
+
+    // Log to Redfish event
+    sendJournalRedfish(description, logLevel);
+}
+
+void OemEventManager::handleDDRStatusEvent(pldm_tid_t tid, uint16_t sensorId,
+                                           uint32_t presentReading)
+{
+    log_level logLevel{log_level::WARNING};
+    std::string description;
+    uint8_t byte3 = (presentReading & 0xff000000) >> 24;
+    uint32_t byte012 = presentReading & 0xffffff;
+
+    description += prefixMsgStrCreation(tid, sensorId);
+
+    description += "DDR ";
+    if (ddrStatusToMsgMap.contains(byte3))
+    {
+        if (byte3 == ddr_status::NO_SYSTEM_LEVEL_ERROR)
+        {
+            logLevel = log_level::OK;
+        }
+
+        description += ddrStatusToMsgMap[byte3];
+
+        if (byte3 == ddr_status::CONFIGURATION_FAILURE ||
+            byte3 == ddr_status::TRAINING_FAILURE)
+        {
+            // List out failed DIMMs
+            description += dimmIdxsToString(byte012);
+        }
+    }
+    else
+    {
+        description += "has unsupported status " + std::to_string(byte3);
+    }
+
+    // Log to Redfish event
+    sendJournalRedfish(description, logLevel);
+}
+
 } // namespace oem_ampere
 } // namespace pldm
diff --git a/oem/ampere/event/oem_event_manager.hpp b/oem/ampere/event/oem_event_manager.hpp
index 46ba526..93186cf 100644
--- a/oem/ampere/event/oem_event_manager.hpp
+++ b/oem/ampere/event/oem_event_manager.hpp
@@ -19,6 +19,7 @@
 
 enum sensor_ids
 {
+    DDR_STATUS = 51,
     PCIE_HOT_PLUG = 169,
     BOOT_OVERALL = 175,
 };
@@ -92,6 +93,95 @@
     } __attribute__((packed)) bits;
 } PCIeHotPlugEventRecord_t;
 
+typedef union
+{
+    uint32_t value;
+    struct
+    {
+        uint32_t type:2;
+        uint32_t mcuRankIdx:3;
+        uint32_t reserved_1:3; // byte0
+        uint32_t sliceNum:4;
+        uint32_t upperNibbStatErr:1;
+        uint32_t lowerNibbStatErr:1;
+        uint32_t reserved_2:2; // byte1
+        uint32_t syndrome:4;
+        uint32_t reserved_3:4; // byte2
+        uint32_t reserved_byte:8;
+    } __attribute__((packed)) bits;
+} DIMMTrainingFailure_t;
+
+namespace ddr
+{
+namespace status
+{
+enum ddr_status
+{
+    NO_SYSTEM_LEVEL_ERROR = 0x01,
+    ECC_INITIALIZATION_FAILURE = 0x04,
+    CONFIGURATION_FAILURE = 0x05,
+    TRAINING_FAILURE = 0x06,
+    OTHER_FAILURE = 0x07,
+    BOOT_FAILURE_NO_VALID_CONFIG = 0x08,
+    FAILSAFE_ACTIVATED_NEXT_BOOT_SUCCESS = 0x09,
+};
+}
+} // namespace ddr
+
+namespace dimm
+{
+namespace status
+{
+enum dimm_status
+{
+    INSTALLED_NO_ERROR = 0x01,
+    NOT_INSTALLED = 0x02,
+    OTHER_FAILURE = 0x07,
+    INSTALLED_BUT_DISABLED = 0x10,
+    TRAINING_FAILURE = 0x12,
+    PMIC_HIGH_TEMP = 0x13,
+    TSx_HIGH_TEMP = 0x14,
+    SPD_HUB_HIGH_TEMP = 0x15,
+    PMIC_TEMP_ALERT = 0x16,
+};
+} // namespace status
+
+namespace training_failure
+{
+enum dimm_training_failure_type
+{
+    PHY_TRAINING_FAILURE_TYPE = 0x01,
+    DIMM_TRAINING_FAILURE_TYPE = 0x02,
+};
+
+namespace phy_syndrome
+{
+enum phy_training_failure_syndrome
+{
+    NA = 0x00,
+    PHY_TRAINING_SETUP_FAILURE = 0x01,
+    CA_LEVELING = 0x02,
+    PHY_WRITE_LEVEL_FAILURE = 0x03,
+    PHY_READ_GATE_LEVELING_FAILURE = 0x04,
+    PHY_READ_LEVEL_FAILURE = 0x05,
+    WRITE_DQ_LEVELING = 0x06,
+    PHY_SW_TRAINING_FAILURE = 0x07,
+};
+} // namespace phy_syndrome
+
+namespace dimm_syndrome
+{
+enum dimm_training_failure_syndrome
+{
+    NA = 0x00,
+    DRAM_VREFDQ_TRAINING_FAILURE = 0x01,
+    LRDIMM_DB_TRAINING_FAILURE = 0x02,
+    LRDRIMM_DB_SW_TRAINING_FAILURE = 0x03,
+};
+} // namespace dimm_syndrome
+} // namespace training_failure
+} // namespace dimm
+
 /**
  * @brief OemEventManager
  *
@@ -153,6 +243,14 @@
      */
     std::string dimmIdxsToString(uint32_t dimmIdxs);
 
+    /** @brief Convert the DIMM training failure into logging string.
+     *
+     *  @param[in] failureInfo - the one-hot DIMM index byte
+     *
+     *  @return std::string - the returned logging string
+     */
+    std::string dimmTrainingFailureToMsg(uint32_t failureInfo);
+
     /** @brief Handle numeric sensor event message from PCIe hot-plug sensor.
      *
      *  @param[in] tid - TID
@@ -171,6 +269,24 @@
     void handleBootOverallEvent(pldm_tid_t /*tid*/, uint16_t /*sensorId*/,
                                 uint32_t presentReading);
 
+    /** @brief Handle numeric sensor event message from DIMM status sensor.
+     *
+     *  @param[in] tid - TID
+     *  @param[in] sensorId - Sensor ID
+     *  @param[in] presentReading - the present reading of the sensor
+     */
+    void handleDIMMStatusEvent(pldm_tid_t tid, uint16_t sensorId,
+                               uint32_t presentReading);
+
+    /** @brief Handle numeric sensor event message from DDR status sensor.
+     *
+     *  @param[in] tid - TID
+     *  @param[in] sensorId - Sensor ID
+     *  @param[in] presentReading - the present reading of the sensor
+     */
+    void handleDDRStatusEvent(pldm_tid_t tid, uint16_t sensorId,
+                              uint32_t presentReading);
+
     /** @brief Handle numeric sensor event messages.
      *
      *  @param[in] tid - TID