1 #pragma once 2 #include "../../common/utils.hpp" 3 #include "../../libpldmresponder/base.hpp" 4 #include "../../libpldmresponder/bios.hpp" 5 #include "../../libpldmresponder/fru.hpp" 6 #include "../../libpldmresponder/platform.hpp" 7 #include "../../oem/ampere/event/oem_event_manager.hpp" 8 #include "../../platform-mc/manager.hpp" 9 #include "../../pldmd/invoker.hpp" 10 #include "../../requester/request.hpp" 11 12 namespace pldm 13 { 14 namespace oem_ampere 15 { 16 17 /** 18 * @class OemAMPERE 19 * 20 * @brief class for creating all the OEM AMPERE handlers 21 * 22 * Only in case of OEM_AMPERE this class object will be instantiated 23 */ 24 class OemAMPERE 25 { 26 public: 27 OemAMPERE() = delete; 28 OemAMPERE& operator=(const OemAMPERE&) = delete; 29 OemAMPERE(OemAMPERE&&) = delete; 30 OemAMPERE& operator=(OemAMPERE&&) = delete; 31 32 public: 33 /** Constructs OemAMPERE object 34 * 35 * @param[in] dBusIntf - D-Bus handler 36 * @param[in] mctp_fd - fd of MCTP communications socket 37 * @param[in] mctp_eid - MCTP EID of remote host firmware 38 * @param[in] repo - pointer to BMC's primary PDR repo 39 * @param[in] instanceIdDb - pointer to an InstanceIdDb object 40 * @param[in] event - sd_event handler 41 * @param[in] invoker - invoker handler 42 * @param[in] hostPDRHandler - hostPDRHandler handler 43 * @param[in] platformHandler - platformHandler handler 44 * @param[in] fruHandler - fruHandler handler 45 * @param[in] baseHandler - baseHandler handler 46 * @param[in] biosHandler - biosHandler handler 47 * @param[in] reqHandler - reqHandler handler 48 */ OemAMPERE(const pldm::utils::DBusHandler *,int,pldm_pdr *,pldm::InstanceIdDb & instanceIdDb,sdeventplus::Event & event,responder::Invoker &,HostPDRHandler *,responder::platform::Handler * platformHandler,responder::fru::Handler *,responder::base::Handler *,responder::bios::Handler *,platform_mc::Manager * platformManager,pldm::requester::Handler<pldm::requester::Request> * reqHandler)49 explicit OemAMPERE( 50 const pldm::utils::DBusHandler* /* dBusIntf */, int /* mctp_fd */, 51 pldm_pdr* /* repo */, pldm::InstanceIdDb& instanceIdDb, 52 sdeventplus::Event& event, responder::Invoker& /* invoker */, 53 HostPDRHandler* /* hostPDRHandler */, 54 responder::platform::Handler* platformHandler, 55 responder::fru::Handler* /* fruHandler */, 56 responder::base::Handler* /* baseHandler */, 57 responder::bios::Handler* /* biosHandler */, 58 platform_mc::Manager* platformManager, 59 pldm::requester::Handler<pldm::requester::Request>* reqHandler) : 60 instanceIdDb(instanceIdDb), event(event), 61 platformHandler(platformHandler), platformManager(platformManager), 62 reqHandler(reqHandler) 63 { 64 oemEventManager = std::make_shared<oem_ampere::OemEventManager>( 65 this->event, this->reqHandler, this->instanceIdDb, 66 this->platformManager); 67 createOemEventHandler(oemEventManager.get(), this->platformManager); 68 } 69 70 private: 71 /** @brief Method for creating OemEventManager 72 * 73 * This method also assigns the OemEventManager to the below 74 * different handlers. 75 */ createOemEventHandler(oem_ampere::OemEventManager * oemEventManager,platform_mc::Manager * platformManager)76 void createOemEventHandler(oem_ampere::OemEventManager* oemEventManager, 77 platform_mc::Manager* platformManager) 78 { 79 platformHandler->registerEventHandlers( 80 PLDM_SENSOR_EVENT, 81 {[oemEventManager](const pldm_msg* request, size_t payloadLength, 82 uint8_t formatVersion, uint8_t tid, 83 size_t eventDataOffset) { 84 return oemEventManager->handleSensorEvent( 85 request, payloadLength, formatVersion, tid, 86 eventDataOffset); 87 }}); 88 89 /* Register Ampere OEM handler to the PLDM CPER events */ 90 platformManager->registerPolledEventHandler( 91 0xFA, 92 {[oemEventManager](pldm_tid_t tid, uint16_t eventId, 93 const uint8_t* eventData, size_t eventDataSize) { 94 return oemEventManager->processOemMsgPollEvent( 95 tid, eventId, eventData, eventDataSize); 96 }}); 97 platformManager->registerPolledEventHandler( 98 PLDM_CPER_EVENT, 99 {[oemEventManager](pldm_tid_t tid, uint16_t eventId, 100 const uint8_t* eventData, size_t eventDataSize) { 101 return oemEventManager->processOemMsgPollEvent( 102 tid, eventId, eventData, eventDataSize); 103 }}); 104 105 /** CPEREvent class (0x07) is only available in DSP0248 V1.3.0. 106 * Before DSP0248 V1.3.0 spec, Ampere uses OEM event class 0xFA to 107 * report the CPER event 108 */ 109 platformHandler->registerEventHandlers( 110 0xFA, 111 {[platformManager](const pldm_msg* request, size_t payloadLength, 112 uint8_t formatVersion, uint8_t tid, 113 size_t eventDataOffset) { 114 return platformManager->handleCperEvent( 115 request, payloadLength, formatVersion, tid, 116 eventDataOffset); 117 }}); 118 /* Support handle the polled event with Ampere OEM CPER event class */ 119 platformManager->registerPolledEventHandler( 120 0xFA, 121 {[platformManager](pldm_tid_t tid, uint16_t eventId, 122 const uint8_t* eventData, size_t eventDataSize) { 123 return platformManager->handlePolledCperEvent( 124 tid, eventId, eventData, eventDataSize); 125 }}); 126 127 /* Register OEM handling for pldmMessagePollEvent */ 128 platformHandler->registerEventHandlers( 129 PLDM_MESSAGE_POLL_EVENT, 130 {[oemEventManager](const pldm_msg* request, size_t payloadLength, 131 uint8_t formatVersion, uint8_t tid, 132 size_t eventDataOffset) { 133 return oemEventManager->handlepldmMessagePollEvent( 134 request, payloadLength, formatVersion, tid, 135 eventDataOffset); 136 }}); 137 138 /* Register Ampere OEM handler to poll the PLDM events */ 139 platformManager->registerOEMPollMethod( 140 [oemEventManager](pldm_tid_t tid) { 141 return oemEventManager->oemPollForPlatformEvent(tid); 142 }); 143 } 144 145 private: 146 /** @brief reference to an Instance ID database object, used to obtain PLDM 147 * instance IDs 148 */ 149 pldm::InstanceIdDb& instanceIdDb; 150 151 /** @brief reference of main event loop of pldmd, primarily used to schedule 152 * work 153 */ 154 sdeventplus::Event& event; 155 156 /** @brief Platform handler*/ 157 responder::platform::Handler* platformHandler = nullptr; 158 159 /** @brief MC Platform manager*/ 160 platform_mc::Manager* platformManager = nullptr; 161 162 /** @brief pointer to the requester class*/ 163 requester::Handler<requester::Request>* reqHandler = nullptr; 164 165 std::shared_ptr<oem_ampere::OemEventManager> oemEventManager{}; 166 }; 167 168 } // namespace oem_ampere 169 } // namespace pldm 170