blob: 4f3969ccfa5e10a03f04a608fa77a8014cb16dfc [file] [log] [blame]
Sampa Misraaea5dde2020-08-31 08:33:47 -05001#include "oem_ibm_handler.hpp"
2
Sagar Srinivascfdbca72020-09-22 10:03:35 -05003#include "file_io_type_lid.hpp"
4#include "libpldmresponder/file_io.hpp"
Sagar Srinivas78a225a2020-08-27 00:52:20 -05005#include "libpldmresponder/pdr_utils.hpp"
Brad Bishop5079ac42021-08-19 18:35:06 -04006
George Liuc453e162022-12-21 17:16:23 +08007#include <libpldm/entity.h>
Andrew Jeffery21f128d2024-01-15 15:34:26 +10308#include <libpldm/oem/ibm/entity.h>
Brad Bishop27403f42021-12-01 21:37:44 -05009
Riya Dixit49cfb132023-03-02 04:26:53 -060010#include <phosphor-logging/lg2.hpp>
Pavithra Barithaya7b4d59a2024-02-05 09:09:30 -060011#include <xyz/openbmc_project/State/BMC/client.hpp>
Riya Dixit49cfb132023-03-02 04:26:53 -060012
13PHOSPHOR_LOG2_USING;
14
Brad Bishop5079ac42021-08-19 18:35:06 -040015using namespace pldm::pdr;
16using namespace pldm::utils;
17
Sampa Misraaea5dde2020-08-31 08:33:47 -050018namespace pldm
19{
Sampa Misraaea5dde2020-08-31 08:33:47 -050020namespace responder
21{
Sampa Misraaea5dde2020-08-31 08:33:47 -050022namespace oem_ibm_platform
23{
Sampa Misraaea5dde2020-08-31 08:33:47 -050024int pldm::responder::oem_ibm_platform::Handler::
25 getOemStateSensorReadingsHandler(
26 EntityType entityType, EntityInstance entityInstance,
27 StateSetId stateSetId, CompositeCount compSensorCnt,
28 std::vector<get_sensor_state_field>& stateField)
29{
30 int rc = PLDM_SUCCESS;
31 stateField.clear();
32
33 for (size_t i = 0; i < compSensorCnt; i++)
34 {
35 uint8_t sensorOpState{};
Sagar Srinivas78a225a2020-08-27 00:52:20 -050036 if (entityType == PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE &&
Sampa Misraaea5dde2020-08-31 08:33:47 -050037 stateSetId == PLDM_OEM_IBM_BOOT_STATE)
38 {
39 sensorOpState = fetchBootSide(entityInstance, codeUpdate);
40 }
41 else
42 {
43 rc = PLDM_PLATFORM_INVALID_STATE_VALUE;
44 break;
45 }
46 stateField.push_back({PLDM_SENSOR_ENABLED, PLDM_SENSOR_UNKNOWN,
47 PLDM_SENSOR_UNKNOWN, sensorOpState});
48 }
49 return rc;
50}
51
52int pldm::responder::oem_ibm_platform::Handler::
Sampa Misra3a0e3b92020-10-21 05:58:00 -050053 oemSetStateEffecterStatesHandler(
Varsha Kaverappa3fbd39e2020-09-28 01:40:22 -050054 uint16_t entityType, uint16_t entityInstance, uint16_t stateSetId,
55 uint8_t compEffecterCnt,
56 std::vector<set_effecter_state_field>& stateField,
57 uint16_t /*effecterId*/)
Sampa Misraaea5dde2020-08-31 08:33:47 -050058{
59 int rc = PLDM_SUCCESS;
60
61 for (uint8_t currState = 0; currState < compEffecterCnt; ++currState)
62 {
63 if (stateField[currState].set_request == PLDM_REQUEST_SET)
64 {
Sagar Srinivas78a225a2020-08-27 00:52:20 -050065 if (entityType == PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE &&
Sampa Misraaea5dde2020-08-31 08:33:47 -050066 stateSetId == PLDM_OEM_IBM_BOOT_STATE)
67 {
68 rc = setBootSide(entityInstance, currState, stateField,
69 codeUpdate);
70 }
Sagar Srinivascfdbca72020-09-22 10:03:35 -050071 else if (entityType == PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE &&
72 stateSetId == PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE)
73 {
74 if (stateField[currState].effecter_state ==
75 uint8_t(CodeUpdateState::START))
76 {
77 codeUpdate->setCodeUpdateProgress(true);
Sampa Misra3a0e3b92020-10-21 05:58:00 -050078 startUpdateEvent =
79 std::make_unique<sdeventplus::source::Defer>(
80 event,
81 std::bind(std::mem_fn(&oem_ibm_platform::Handler::
82 _processStartUpdate),
83 this, std::placeholders::_1));
Sagar Srinivascfdbca72020-09-22 10:03:35 -050084 }
85 else if (stateField[currState].effecter_state ==
86 uint8_t(CodeUpdateState::END))
87 {
Sampa Misra3a0e3b92020-10-21 05:58:00 -050088 rc = PLDM_SUCCESS;
89 assembleImageEvent = std::make_unique<
90 sdeventplus::source::Defer>(
91 event,
92 std::bind(
93 std::mem_fn(
94 &oem_ibm_platform::Handler::_processEndUpdate),
95 this, std::placeholders::_1));
96
97 // sendCodeUpdateEvent(effecterId, END, START);
Sagar Srinivascfdbca72020-09-22 10:03:35 -050098 }
99 else if (stateField[currState].effecter_state ==
100 uint8_t(CodeUpdateState::ABORT))
101 {
102 codeUpdate->setCodeUpdateProgress(false);
103 codeUpdate->clearDirPath(LID_STAGING_DIR);
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500104 auto sensorId = codeUpdate->getFirmwareUpdateSensor();
105 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0,
106 uint8_t(CodeUpdateState::ABORT),
107 uint8_t(CodeUpdateState::START));
108 // sendCodeUpdateEvent(effecterId, ABORT, END);
Sagar Srinivascfdbca72020-09-22 10:03:35 -0500109 }
110 else if (stateField[currState].effecter_state ==
111 uint8_t(CodeUpdateState::ACCEPT))
112 {
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500113 auto sensorId = codeUpdate->getFirmwareUpdateSensor();
114 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0,
115 uint8_t(CodeUpdateState::ACCEPT),
116 uint8_t(CodeUpdateState::END));
Sagar Srinivascfdbca72020-09-22 10:03:35 -0500117 // TODO Set new Dbus property provided by code update app
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500118 // sendCodeUpdateEvent(effecterId, ACCEPT, END);
Sagar Srinivascfdbca72020-09-22 10:03:35 -0500119 }
120 else if (stateField[currState].effecter_state ==
121 uint8_t(CodeUpdateState::REJECT))
122 {
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500123 auto sensorId = codeUpdate->getFirmwareUpdateSensor();
124 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0,
125 uint8_t(CodeUpdateState::REJECT),
126 uint8_t(CodeUpdateState::END));
Sagar Srinivascfdbca72020-09-22 10:03:35 -0500127 // TODO Set new Dbus property provided by code update app
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500128 // sendCodeUpdateEvent(effecterId, REJECT, END);
Sagar Srinivascfdbca72020-09-22 10:03:35 -0500129 }
130 }
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600131 else if (entityType == PLDM_ENTITY_SYSTEM_CHASSIS &&
132 stateSetId == PLDM_OEM_IBM_SYSTEM_POWER_STATE)
133 {
134 if (stateField[currState].effecter_state == POWER_CYCLE_HARD)
135 {
136 systemRebootEvent =
137 std::make_unique<sdeventplus::source::Defer>(
138 event,
139 std::bind(std::mem_fn(&oem_ibm_platform::Handler::
140 _processSystemReboot),
141 this, std::placeholders::_1));
142 }
143 }
Sampa Misraaea5dde2020-08-31 08:33:47 -0500144 else
145 {
146 rc = PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE;
147 }
148 }
149 if (rc != PLDM_SUCCESS)
150 {
151 break;
152 }
153 }
154 return rc;
155}
156
Manojkiran Eda6b1d8832021-03-27 11:25:06 +0530157void buildAllCodeUpdateEffecterPDR(oem_ibm_platform::Handler* platformHandler,
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600158 uint16_t entityType, uint16_t entityInstance,
159 uint16_t stateSetID, pdr_utils::Repo& repo)
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500160{
161 size_t pdrSize = 0;
162 pdrSize = sizeof(pldm_state_effecter_pdr) +
163 sizeof(state_effecter_possible_states);
164 std::vector<uint8_t> entry{};
165 entry.resize(pdrSize);
166 pldm_state_effecter_pdr* pdr =
167 reinterpret_cast<pldm_state_effecter_pdr*>(entry.data());
168 if (!pdr)
169 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600170 error("Failed to get record by PDR type, ERROR:{ERR_CODE}", "ERR_CODE",
171 lg2::hex,
172 static_cast<unsigned>(PLDM_PLATFORM_INVALID_EFFECTER_ID));
Manojkiran Edabcf91ac2021-03-14 13:50:48 +0530173 return;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500174 }
175 pdr->hdr.record_handle = 0;
176 pdr->hdr.version = 1;
177 pdr->hdr.type = PLDM_STATE_EFFECTER_PDR;
178 pdr->hdr.record_change_num = 0;
179 pdr->hdr.length = sizeof(pldm_state_effecter_pdr) - sizeof(pldm_pdr_hdr);
Manojkiran Edacc5f1582021-09-29 17:03:06 +0530180 pdr->terminus_handle = TERMINUS_HANDLE;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500181 pdr->effecter_id = platformHandler->getNextEffecterId();
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600182 pdr->entity_type = entityType;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500183 pdr->entity_instance = entityInstance;
Sagar Srinivas97296e02021-08-26 09:40:41 -0500184 pdr->container_id = 1;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500185 pdr->effecter_semantic_id = 0;
186 pdr->effecter_init = PLDM_NO_INIT;
187 pdr->has_description_pdr = false;
188 pdr->composite_effecter_count = 1;
189
190 auto* possibleStatesPtr = pdr->possible_states;
191 auto possibleStates =
192 reinterpret_cast<state_effecter_possible_states*>(possibleStatesPtr);
193 possibleStates->state_set_id = stateSetID;
194 possibleStates->possible_states_size = 2;
195 auto state =
196 reinterpret_cast<state_effecter_possible_states*>(possibleStates);
197 if (stateSetID == PLDM_OEM_IBM_BOOT_STATE)
198 state->states[0].byte = 6;
199 else if (stateSetID == PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE)
200 state->states[0].byte = 126;
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600201 else if (stateSetID == PLDM_OEM_IBM_SYSTEM_POWER_STATE)
202 state->states[0].byte = 2;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500203 pldm::responder::pdr_utils::PdrEntry pdrEntry{};
204 pdrEntry.data = entry.data();
205 pdrEntry.size = pdrSize;
206 repo.addRecord(pdrEntry);
207}
208
Manojkiran Eda6b1d8832021-03-27 11:25:06 +0530209void buildAllCodeUpdateSensorPDR(oem_ibm_platform::Handler* platformHandler,
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500210 uint16_t entityType, uint16_t entityInstance,
211 uint16_t stateSetID, pdr_utils::Repo& repo)
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500212{
213 size_t pdrSize = 0;
Patrick Williams6da4f912023-05-10 07:50:53 -0500214 pdrSize = sizeof(pldm_state_sensor_pdr) +
215 sizeof(state_sensor_possible_states);
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500216 std::vector<uint8_t> entry{};
217 entry.resize(pdrSize);
218 pldm_state_sensor_pdr* pdr =
219 reinterpret_cast<pldm_state_sensor_pdr*>(entry.data());
220 if (!pdr)
221 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600222 error("Failed to get record by PDR type, ERROR:{ERR_CODE}", "ERR_CODE",
223 lg2::hex, static_cast<unsigned>(PLDM_PLATFORM_INVALID_SENSOR_ID));
Manojkiran Edabcf91ac2021-03-14 13:50:48 +0530224 return;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500225 }
226 pdr->hdr.record_handle = 0;
227 pdr->hdr.version = 1;
228 pdr->hdr.type = PLDM_STATE_SENSOR_PDR;
229 pdr->hdr.record_change_num = 0;
230 pdr->hdr.length = sizeof(pldm_state_sensor_pdr) - sizeof(pldm_pdr_hdr);
Manojkiran Edacc5f1582021-09-29 17:03:06 +0530231 pdr->terminus_handle = TERMINUS_HANDLE;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500232 pdr->sensor_id = platformHandler->getNextSensorId();
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500233 pdr->entity_type = entityType;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500234 pdr->entity_instance = entityInstance;
Sagar Srinivas97296e02021-08-26 09:40:41 -0500235 pdr->container_id = 1;
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500236 pdr->sensor_init = PLDM_NO_INIT;
237 pdr->sensor_auxiliary_names_pdr = false;
238 pdr->composite_sensor_count = 1;
239
240 auto* possibleStatesPtr = pdr->possible_states;
241 auto possibleStates =
242 reinterpret_cast<state_sensor_possible_states*>(possibleStatesPtr);
243 possibleStates->state_set_id = stateSetID;
244 possibleStates->possible_states_size = 2;
245 auto state =
246 reinterpret_cast<state_sensor_possible_states*>(possibleStates);
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500247 if ((stateSetID == PLDM_OEM_IBM_BOOT_STATE) ||
Christian Geddes7f9523c2021-08-03 13:44:38 -0500248 (stateSetID == PLDM_OEM_IBM_VERIFICATION_STATE))
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500249 state->states[0].byte = 6;
250 else if (stateSetID == PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE)
251 state->states[0].byte = 126;
252 pldm::responder::pdr_utils::PdrEntry pdrEntry{};
253 pdrEntry.data = entry.data();
254 pdrEntry.size = pdrSize;
255 repo.addRecord(pdrEntry);
256}
257
258void pldm::responder::oem_ibm_platform::Handler::buildOEMPDR(
259 pdr_utils::Repo& repo)
260{
Manojkiran Eda6b1d8832021-03-27 11:25:06 +0530261 buildAllCodeUpdateEffecterPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
262 ENTITY_INSTANCE_0, PLDM_OEM_IBM_BOOT_STATE,
263 repo);
264 buildAllCodeUpdateEffecterPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
265 ENTITY_INSTANCE_1, PLDM_OEM_IBM_BOOT_STATE,
266 repo);
267 buildAllCodeUpdateEffecterPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
268 ENTITY_INSTANCE_0,
269 PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE, repo);
270 buildAllCodeUpdateEffecterPDR(this, PLDM_ENTITY_SYSTEM_CHASSIS,
Sagar Srinivas1b8d35f2021-11-10 10:54:40 -0600271 ENTITY_INSTANCE_1,
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600272 PLDM_OEM_IBM_SYSTEM_POWER_STATE, repo);
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500273
Manojkiran Eda6b1d8832021-03-27 11:25:06 +0530274 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
275 ENTITY_INSTANCE_0, PLDM_OEM_IBM_BOOT_STATE,
276 repo);
277 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
278 ENTITY_INSTANCE_1, PLDM_OEM_IBM_BOOT_STATE,
279 repo);
280 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
281 ENTITY_INSTANCE_0,
282 PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE, repo);
283 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
284 ENTITY_INSTANCE_0,
285 PLDM_OEM_IBM_VERIFICATION_STATE, repo);
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500286 auto sensorId = findStateSensorId(
287 repo.getPdr(), 0, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
Sagar Srinivasf4a7dd72021-10-20 04:45:37 -0500288 ENTITY_INSTANCE_0, 1, PLDM_OEM_IBM_VERIFICATION_STATE);
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500289 codeUpdate->setMarkerLidSensor(sensorId);
290 sensorId = findStateSensorId(
291 repo.getPdr(), 0, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE,
Sagar Srinivasf4a7dd72021-10-20 04:45:37 -0500292 ENTITY_INSTANCE_0, 1, PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE);
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500293 codeUpdate->setFirmwareUpdateSensor(sensorId);
Sagar Srinivas78a225a2020-08-27 00:52:20 -0500294}
295
Sampa Misraaea5dde2020-08-31 08:33:47 -0500296void pldm::responder::oem_ibm_platform::Handler::setPlatformHandler(
297 pldm::responder::platform::Handler* handler)
298{
299 platformHandler = handler;
300}
301
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500302int pldm::responder::oem_ibm_platform::Handler::sendEventToHost(
Sampa Misrac0c79482021-06-02 08:01:54 -0500303 std::vector<uint8_t>& requestMsg, uint8_t instanceId)
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500304{
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500305 if (requestMsg.size())
306 {
307 std::ostringstream tempStream;
308 for (int byte : requestMsg)
309 {
310 tempStream << std::setfill('0') << std::setw(2) << std::hex << byte
311 << " ";
312 }
313 std::cout << tempStream.str() << std::endl;
314 }
Patrick Williams6da4f912023-05-10 07:50:53 -0500315 auto oemPlatformEventMessageResponseHandler =
316 [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) {
Riya Dixit49cfb132023-03-02 04:26:53 -0600317 uint8_t completionCode{};
318 uint8_t status{};
319 auto rc = decode_platform_event_message_resp(response, respMsgLen,
320 &completionCode, &status);
321 if (rc || completionCode)
322 {
323 error(
324 "Failed to decode_platform_event_message_resp: for code update event rc={RC}, cc={CC}",
325 "RC", rc, "CC", static_cast<unsigned>(completionCode));
326 }
327 };
Sampa Misrac0c79482021-06-02 08:01:54 -0500328 auto rc = handler->registerRequest(
329 mctp_eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE,
330 std::move(requestMsg),
331 std::move(oemPlatformEventMessageResponseHandler));
332 if (rc)
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500333 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600334 error("Failed to send BIOS attribute change event message ");
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500335 }
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500336
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500337 return rc;
338}
339
340int encodeEventMsg(uint8_t eventType, const std::vector<uint8_t>& eventDataVec,
341 std::vector<uint8_t>& requestMsg, uint8_t instanceId)
342{
343 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
344
345 auto rc = encode_platform_event_message_req(
ArchanaKakani6c39c7a2022-12-05 04:36:35 -0600346 instanceId, 1 /*formatVersion*/, TERMINUS_ID /*tId*/, eventType,
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500347 eventDataVec.data(), eventDataVec.size(), request,
348 eventDataVec.size() + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES);
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500349
350 return rc;
351}
352
353void pldm::responder::oem_ibm_platform::Handler::sendStateSensorEvent(
354 uint16_t sensorId, enum sensor_event_class_states sensorEventClass,
355 uint8_t sensorOffset, uint8_t eventState, uint8_t prevEventState)
356{
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500357 std::vector<uint8_t> sensorEventDataVec{};
358 size_t sensorEventSize = PLDM_SENSOR_EVENT_DATA_MIN_LENGTH + 1;
359 sensorEventDataVec.resize(sensorEventSize);
360 auto eventData = reinterpret_cast<struct pldm_sensor_event_data*>(
361 sensorEventDataVec.data());
362 eventData->sensor_id = sensorId;
363 eventData->sensor_event_class_type = sensorEventClass;
364 auto eventClassStart = eventData->event_class;
365 auto eventClass =
366 reinterpret_cast<struct pldm_sensor_event_state_sensor_state*>(
367 eventClassStart);
368 eventClass->sensor_offset = sensorOffset;
369 eventClass->event_state = eventState;
370 eventClass->previous_event_state = prevEventState;
Andrew Jefferya330b2f2023-05-04 14:55:37 +0930371 auto instanceId = instanceIdDb.next(mctp_eid);
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500372 std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
373 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
374 sensorEventDataVec.size());
375 auto rc = encodeEventMsg(PLDM_SENSOR_EVENT, sensorEventDataVec, requestMsg,
376 instanceId);
377 if (rc != PLDM_SUCCESS)
378 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600379 error("Failed to encode state sensor event, rc = {RC}", "RC", rc);
Andrew Jefferya330b2f2023-05-04 14:55:37 +0930380 instanceIdDb.free(mctp_eid, instanceId);
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500381 return;
382 }
Sampa Misrac0c79482021-06-02 08:01:54 -0500383 rc = sendEventToHost(requestMsg, instanceId);
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500384 if (rc != PLDM_SUCCESS)
385 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600386 error("Failed to send event to host: rc={RC}", "RC", rc);
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500387 }
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500388 return;
389}
390
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500391void pldm::responder::oem_ibm_platform::Handler::_processEndUpdate(
392 sdeventplus::source::EventBase& /*source */)
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500393{
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500394 assembleImageEvent.reset();
Adriana Kobylak9296f242021-09-22 15:52:00 +0000395 int retc = codeUpdate->assembleCodeUpdateImage();
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500396 if (retc != PLDM_SUCCESS)
397 {
398 codeUpdate->setCodeUpdateProgress(false);
399 auto sensorId = codeUpdate->getFirmwareUpdateSensor();
400 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0,
401 uint8_t(CodeUpdateState::FAIL),
402 uint8_t(CodeUpdateState::START));
403 }
404}
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500405
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500406void pldm::responder::oem_ibm_platform::Handler::_processStartUpdate(
407 sdeventplus::source::EventBase& /*source */)
408{
409 codeUpdate->deleteImage();
410 CodeUpdateState state = CodeUpdateState::START;
411 auto rc = codeUpdate->setRequestedApplyTime();
412 if (rc != PLDM_SUCCESS)
413 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600414 error("setRequestedApplyTime failed");
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500415 state = CodeUpdateState::FAIL;
416 }
417 auto sensorId = codeUpdate->getFirmwareUpdateSensor();
418 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0, uint8_t(state),
419 uint8_t(CodeUpdateState::END));
Varsha Kaverappabb585b22020-09-10 06:15:42 -0500420}
421
Kamalkumar Patel15ce5a12024-05-07 11:45:11 -0500422void pldm::responder::oem_ibm_platform::Handler::updateOemDbusPaths(
423 std::string& dbusPath)
424{
425 std::string toFind("system1/chassis1/motherboard1");
426 if (dbusPath.find(toFind) != std::string::npos)
427 {
428 size_t pos = dbusPath.find(toFind);
429 dbusPath.replace(pos, toFind.length(), "system/chassis/motherboard");
430 }
431 toFind = "system1";
432 if (dbusPath.find(toFind) != std::string::npos)
433 {
434 size_t pos = dbusPath.find(toFind);
435 dbusPath.replace(pos, toFind.length(), "system");
436 }
437 /* below logic to replace path 'motherboard/socket/chassis' to
438 'motherboard/chassis' or 'motherboard/socket123/chassis' to
439 'motherboard/chassis' */
440 toFind = "socket";
441 size_t pos1 = dbusPath.find(toFind);
442 // while loop to detect multiple substring 'socket' in the path
443 while (pos1 != std::string::npos)
444 {
445 size_t pos2 = dbusPath.substr(pos1 + 1).find('/') + 1;
446 // Replacing starting from substring to next occurence of char '/'
447 dbusPath.replace(pos1, pos2 + 1, "");
448 pos1 = dbusPath.find(toFind);
449 }
450}
451
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600452void pldm::responder::oem_ibm_platform::Handler::_processSystemReboot(
453 sdeventplus::source::EventBase& /*source */)
454{
455 pldm::utils::PropertyValue value =
456 "xyz.openbmc_project.State.Chassis.Transition.Off";
457 pldm::utils::DBusMapping dbusMapping{"/xyz/openbmc_project/state/chassis0",
458 "xyz.openbmc_project.State.Chassis",
459 "RequestedPowerTransition", "string"};
460 try
461 {
462 dBusIntf->setDbusProperty(dbusMapping, value);
463 }
464 catch (const std::exception& e)
465 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600466 error(
467 "Chassis State transition to Off failed, unable to set property RequestedPowerTransition ERROR={ERR_EXCEP}",
468 "ERR_EXCEP", e.what());
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600469 }
470
471 using namespace sdbusplus::bus::match::rules;
Patrick Williams84b790c2022-07-22 19:26:56 -0500472 chassisOffMatch = std::make_unique<sdbusplus::bus::match_t>(
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600473 pldm::utils::DBusHandler::getBus(),
474 propertiesChanged("/xyz/openbmc_project/state/chassis0",
475 "xyz.openbmc_project.State.Chassis"),
Patrick Williams84b790c2022-07-22 19:26:56 -0500476 [this](sdbusplus::message_t& msg) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500477 DbusChangedProps props{};
478 std::string intf;
479 msg.read(intf, props);
480 const auto itr = props.find("CurrentPowerState");
481 if (itr != props.end())
482 {
483 PropertyValue value = itr->second;
484 auto propVal = std::get<std::string>(value);
485 if (propVal == "xyz.openbmc_project.State.Chassis.PowerState.Off")
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600486 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500487 pldm::utils::DBusMapping dbusMapping{
488 "/xyz/openbmc_project/control/host0/"
489 "power_restore_policy/one_time",
490 "xyz.openbmc_project.Control.Power.RestorePolicy",
491 "PowerRestorePolicy", "string"};
492 value = "xyz.openbmc_project.Control.Power.RestorePolicy."
493 "Policy.AlwaysOn";
494 try
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600495 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500496 dBusIntf->setDbusProperty(dbusMapping, value);
497 }
498 catch (const std::exception& e)
499 {
500 error(
501 "Setting one-time restore policy failed, unable to set property PowerRestorePolicy ERROR={ERR_EXCEP}",
502 "ERR_EXCEP", e.what());
503 }
504 dbusMapping = pldm::utils::DBusMapping{
505 "/xyz/openbmc_project/state/bmc0",
506 "xyz.openbmc_project.State.BMC", "RequestedBMCTransition",
507 "string"};
508 value = "xyz.openbmc_project.State.BMC.Transition.Reboot";
509 try
510 {
511 dBusIntf->setDbusProperty(dbusMapping, value);
512 }
513 catch (const std::exception& e)
514 {
515 error(
516 "BMC state transition to reboot failed, unable to set property RequestedBMCTransition ERROR={ERR_EXCEP}",
517 "ERR_EXCEP", e.what());
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600518 }
519 }
Patrick Williams6da4f912023-05-10 07:50:53 -0500520 }
Patrick Williamsa6756622023-10-20 11:19:15 -0500521 });
Sagar Srinivas9a64b4a2021-02-09 07:55:38 -0600522}
Sagar Srinivas79669c92021-04-28 15:43:30 -0500523
Sagar Srinivas7f760b32021-05-12 07:46:56 -0500524void pldm::responder::oem_ibm_platform::Handler::checkAndDisableWatchDog()
525{
526 if (!hostOff && setEventReceiverCnt == SET_EVENT_RECEIVER_SENT)
527 {
528 disableWatchDogTimer();
529 }
530
531 return;
532}
533
Sagar Srinivas79669c92021-04-28 15:43:30 -0500534bool pldm::responder::oem_ibm_platform::Handler::watchDogRunning()
535{
536 static constexpr auto watchDogObjectPath =
537 "/xyz/openbmc_project/watchdog/host0";
538 static constexpr auto watchDogEnablePropName = "Enabled";
539 static constexpr auto watchDogInterface =
540 "xyz.openbmc_project.State.Watchdog";
541 bool isWatchDogRunning = false;
542 try
543 {
544 isWatchDogRunning = pldm::utils::DBusHandler().getDbusProperty<bool>(
545 watchDogObjectPath, watchDogEnablePropName, watchDogInterface);
546 }
Kamalkumar Patel58cbcaf2023-10-06 03:48:25 -0500547 catch (const std::exception&)
Sagar Srinivas79669c92021-04-28 15:43:30 -0500548 {
549 return false;
550 }
551 return isWatchDogRunning;
552}
553
554void pldm::responder::oem_ibm_platform::Handler::resetWatchDogTimer()
555{
556 static constexpr auto watchDogService = "xyz.openbmc_project.Watchdog";
557 static constexpr auto watchDogObjectPath =
558 "/xyz/openbmc_project/watchdog/host0";
559 static constexpr auto watchDogInterface =
560 "xyz.openbmc_project.State.Watchdog";
561 static constexpr auto watchDogResetPropName = "ResetTimeRemaining";
562
563 bool wdStatus = watchDogRunning();
564 if (wdStatus == false)
565 {
566 return;
567 }
568 try
569 {
570 auto& bus = pldm::utils::DBusHandler::getBus();
571 auto resetMethod =
572 bus.new_method_call(watchDogService, watchDogObjectPath,
573 watchDogInterface, watchDogResetPropName);
574 resetMethod.append(true);
vkaverap@in.ibm.com5b71b862023-08-21 05:19:04 +0000575 bus.call_noreply(resetMethod, dbusTimeout);
Sagar Srinivas79669c92021-04-28 15:43:30 -0500576 }
577 catch (const std::exception& e)
578 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600579 error("Failed To reset watchdog timer ERROR={ERR_EXCEP}", "ERR_EXCEP",
580 e.what());
Sagar Srinivas79669c92021-04-28 15:43:30 -0500581 return;
582 }
583}
Sagar Srinivas7f760b32021-05-12 07:46:56 -0500584
585void pldm::responder::oem_ibm_platform::Handler::disableWatchDogTimer()
586{
587 setEventReceiverCnt = 0;
588 pldm::utils::DBusMapping dbusMapping{"/xyz/openbmc_project/watchdog/host0",
589 "xyz.openbmc_project.State.Watchdog",
590 "Enabled", "bool"};
591 bool wdStatus = watchDogRunning();
592
593 if (!wdStatus)
594 {
595 return;
596 }
597 try
598 {
599 pldm::utils::DBusHandler().setDbusProperty(dbusMapping, false);
600 }
601 catch (const std::exception& e)
602 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600603 error("Failed To disable watchdog timer ERROR={ERR_EXCEP}", "ERR_EXCEP",
604 e.what());
Sagar Srinivas7f760b32021-05-12 07:46:56 -0500605 }
606}
Pavithra Barithaya99854a72021-09-29 06:58:11 -0500607int pldm::responder::oem_ibm_platform::Handler::checkBMCState()
608{
Pavithra Barithaya7b4d59a2024-02-05 09:09:30 -0600609 using BMC = sdbusplus::client::xyz::openbmc_project::state::BMC<>;
610 auto bmcPath = sdbusplus::message::object_path(BMC::namespace_path::value) /
611 BMC::namespace_path::bmc;
Pavithra Barithaya99854a72021-09-29 06:58:11 -0500612 try
613 {
614 pldm::utils::PropertyValue propertyValue =
615 pldm::utils::DBusHandler().getDbusPropertyVariant(
Pavithra Barithaya7b4d59a2024-02-05 09:09:30 -0600616 bmcPath.str.c_str(), "CurrentBMCState", BMC::interface);
Pavithra Barithaya99854a72021-09-29 06:58:11 -0500617
618 if (std::get<std::string>(propertyValue) ==
619 "xyz.openbmc_project.State.BMC.BMCState.NotReady")
620 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600621 error("GetPDR : PLDM stack is not ready for PDR exchange");
Pavithra Barithaya99854a72021-09-29 06:58:11 -0500622 return PLDM_ERROR_NOT_READY;
623 }
624 }
625 catch (const std::exception& e)
626 {
Kamalkumar Patel58cbcaf2023-10-06 03:48:25 -0500627 error("Error getting the current BMC state: {ERROR}", "ERROR", e);
Pavithra Barithaya99854a72021-09-29 06:58:11 -0500628 return PLDM_ERROR;
629 }
630 return PLDM_SUCCESS;
631}
632
Sagar Srinivas3687e2b2023-04-10 05:08:28 -0500633const pldm_pdr_record*
634 pldm::responder::oem_ibm_platform::Handler::fetchLastBMCRecord(
635 const pldm_pdr* repo)
636{
637 return pldm_pdr_find_last_in_range(repo, BMC_PDR_START_RANGE,
638 BMC_PDR_END_RANGE);
639}
640
641bool pldm::responder::oem_ibm_platform::Handler::checkRecordHandleInRange(
642 const uint32_t& record_handle)
643{
644 return record_handle >= HOST_PDR_START_RANGE &&
645 record_handle <= HOST_PDR_END_RANGE;
646}
647
Sagar Srinivas90314a32023-10-17 10:38:03 -0500648void Handler::processSetEventReceiver()
649{
650 this->setEventReceiver();
651}
652
Sampa Misraaea5dde2020-08-31 08:33:47 -0500653} // namespace oem_ibm_platform
Sampa Misraaea5dde2020-08-31 08:33:47 -0500654} // namespace responder
Sampa Misraaea5dde2020-08-31 08:33:47 -0500655} // namespace pldm