diff --git a/oem/ampere/oem_ampere.hpp b/oem/ampere/oem_ampere.hpp
index 00d8b90..8fb926e 100644
--- a/oem/ampere/oem_ampere.hpp
+++ b/oem/ampere/oem_ampere.hpp
@@ -55,14 +55,15 @@
         responder::fru::Handler* /* fruHandler */,
         responder::base::Handler* /* baseHandler */,
         responder::bios::Handler* /* biosHandler */,
-        platform_mc::Manager* /* platformManager */,
+        platform_mc::Manager* platformManager,
         pldm::requester::Handler<pldm::requester::Request>* reqHandler) :
         instanceIdDb(instanceIdDb), event(event),
-        platformHandler(platformHandler), reqHandler(reqHandler)
+        platformHandler(platformHandler), platformManager(platformManager),
+        reqHandler(reqHandler)
     {
         oemEventManager = std::make_shared<oem_ampere::OemEventManager>(
             this->event, this->reqHandler, this->instanceIdDb);
-        createOemEventHandler(oemEventManager);
+        createOemEventHandler(oemEventManager, this->platformManager);
     }
 
   private:
@@ -72,7 +73,8 @@
      *  different handlers.
      */
     void createOemEventHandler(
-        std::shared_ptr<oem_ampere::OemEventManager> oemEventManager)
+        std::shared_ptr<oem_ampere::OemEventManager> oemEventManager,
+        platform_mc::Manager* platformManager)
     {
         platformHandler->registerEventHandlers(
             PLDM_SENSOR_EVENT,
@@ -83,6 +85,27 @@
                     request, payloadLength, formatVersion, tid,
                     eventDataOffset);
             }});
+        /** CPEREvent class (0x07) is only available in DSP0248 V1.3.0.
+         *  Before DSP0248 V1.3.0 spec, Ampere uses OEM event class 0xFA to
+         *  report the CPER event
+         */
+        platformHandler->registerEventHandlers(
+            0xFA,
+            {[platformManager](const pldm_msg* request, size_t payloadLength,
+                               uint8_t formatVersion, uint8_t tid,
+                               size_t eventDataOffset) {
+                return platformManager->handleCperEvent(
+                    request, payloadLength, formatVersion, tid,
+                    eventDataOffset);
+            }});
+        /* Support handle the polled event with Ampere OEM CPER event class */
+        platformManager->registerPolledEventHandler(
+            0xFA,
+            [platformManager](pldm_tid_t tid, uint16_t eventId,
+                              const uint8_t* eventData, size_t eventDataSize) {
+                return platformManager->handlePolledCperEvent(
+                    tid, eventId, eventData, eventDataSize);
+            });
     }
 
   private:
@@ -99,6 +122,9 @@
     /** @brief Platform handler*/
     responder::platform::Handler* platformHandler = nullptr;
 
+    /** @brief MC Platform manager*/
+    platform_mc::Manager* platformManager = nullptr;
+
     /** @brief pointer to the requester class*/
     requester::Handler<requester::Request>* reqHandler = nullptr;
 
diff --git a/platform-mc/event_manager.hpp b/platform-mc/event_manager.hpp
index 14b6c8e..08ec3bc 100644
--- a/platform-mc/event_manager.hpp
+++ b/platform-mc/event_manager.hpp
@@ -110,7 +110,8 @@
     /** @brief Register response handler for the polled events from
      *         PollForPlatFormEventMessage
      */
-    void registerPolledEventHandler(uint8_t eventClass, HandlerFunc function)
+    void registerPolledEventHandler(uint8_t eventClass,
+                                    pldm::platform_mc::HandlerFunc function)
     {
         eventHandlers.insert_or_assign(eventClass, std::move(function));
     }
diff --git a/platform-mc/manager.hpp b/platform-mc/manager.hpp
index 0cb0178..7def32b 100644
--- a/platform-mc/manager.hpp
+++ b/platform-mc/manager.hpp
@@ -181,6 +181,35 @@
     exec::task<int> pollForPlatformEvent(pldm_tid_t tid, uint16_t pollEventId,
                                          uint32_t pollDataTransferHandle);
 
+    /** @brief Handle Polled CPER event
+     *
+     *  @param[in] tid - tid where the event is from
+     *  @param[in] eventId - event Id
+     *  @param[in] eventData - event data
+     *  @param[in] eventDataSize - size of event data
+     *  @return PLDM completion code
+     */
+    int handlePolledCperEvent(pldm_tid_t tid, uint16_t eventId,
+                              const uint8_t* eventData, size_t eventDataSize)
+    {
+        return eventManager.handlePlatformEvent(tid, eventId, PLDM_CPER_EVENT,
+                                                eventData, eventDataSize);
+    }
+
+    /** @brief The helper function to allow register the handler function for
+     *         the polled event by PollForPlatformEventMessage
+     *
+     *  @param[in] eventClass - Event class
+     *  @param[in] handlerFunc - Event handler
+     *
+     */
+    void registerPolledEventHandler(uint8_t eventClass,
+                                    pldm::platform_mc::HandlerFunc handlerFunc)
+    {
+        eventManager.registerPolledEventHandler(eventClass,
+                                                std::move(handlerFunc));
+    }
+
   private:
     /** @brief List of discovered termini */
     TerminiMapper termini{};