| #pragma once |
| |
| #include "config.h" |
| |
| #include "handler.hpp" |
| #include "libpldmresponder/pdr.hpp" |
| #include "libpldmresponder/pdr_utils.hpp" |
| #include "utils.hpp" |
| |
| #include <stdint.h> |
| |
| #include <map> |
| |
| #include "libpldm/platform.h" |
| #include "libpldm/states.h" |
| |
| namespace pldm |
| { |
| namespace responder |
| { |
| namespace platform |
| { |
| |
| using DbusPath = std::string; |
| using EffecterObjs = std::vector<DbusPath>; |
| |
| class Handler : public CmdHandler |
| { |
| public: |
| Handler(const std::string& dir, pldm_pdr* repo) : pdrRepo(repo) |
| { |
| generate(dir, pdrRepo); |
| |
| handlers.emplace(PLDM_GET_PDR, |
| [this](const pldm_msg* request, size_t payloadLength) { |
| return this->getPDR(request, payloadLength); |
| }); |
| handlers.emplace(PLDM_SET_STATE_EFFECTER_STATES, |
| [this](const pldm_msg* request, size_t payloadLength) { |
| return this->setStateEffecterStates(request, |
| payloadLength); |
| }); |
| } |
| |
| const EffecterObjs& getEffecterObjs(uint16_t effecterId) const |
| { |
| return effecterObjs.at(effecterId); |
| } |
| |
| void addEffecterObjs(uint16_t effecterId, EffecterObjs&& paths) |
| { |
| effecterObjs.emplace(effecterId, std::move(paths)); |
| } |
| |
| uint16_t getNextEffecterId() |
| { |
| return ++nextEffecterId; |
| } |
| |
| /** @brief Parse PDR JSONs and build PDR repository |
| * |
| * @param[in] dir - directory housing platform specific PDR JSON files |
| * @param[in] repo - instance of concrete implementation of Repo |
| */ |
| void generate(const std::string& dir, Repo& repo); |
| |
| /** @brief Parse PDR JSONs and build state effecter PDR repository |
| * |
| * @param[in] json - platform specific PDR JSON files |
| * @param[in] repo - instance of state effecter implementation of Repo |
| */ |
| void generateStateEffecterRepo(const Json& json, Repo& repo); |
| |
| /** @brief Handler for GetPDR |
| * |
| * @param[in] request - Request message payload |
| * @param[in] payloadLength - Request payload length |
| * @param[out] Response - Response message written here |
| */ |
| Response getPDR(const pldm_msg* request, size_t payloadLength); |
| |
| /** @brief Handler for setStateEffecterStates |
| * |
| * @param[in] request - Request message |
| * @param[in] payloadLength - Request payload length |
| * @return Response - PLDM Response message |
| */ |
| Response setStateEffecterStates(const pldm_msg* request, |
| size_t payloadLength); |
| |
| /** @brief Function to set the effecter requested by pldm requester |
| * @param[in] dBusIntf - The interface object |
| * @param[in] effecterId - Effecter ID sent by the requester to act on |
| * @param[in] stateField - The state field data for each of the states, |
| * equal to composite effecter count in number |
| * @return - Success or failure in setting the states. Returns failure in |
| * terms of PLDM completion codes if atleast one state fails to be set |
| */ |
| template <class DBusInterface> |
| int setStateEffecterStatesHandler( |
| const DBusInterface& dBusIntf, uint16_t effecterId, |
| const std::vector<set_effecter_state_field>& stateField) |
| { |
| using namespace pldm::responder::pdr; |
| using namespace std::string_literals; |
| using DBusProperty = std::variant<std::string, bool>; |
| using StateSetId = uint16_t; |
| using StateSetNum = uint8_t; |
| using PropertyMap = |
| std::map<StateSetId, std::map<StateSetNum, DBusProperty>>; |
| static const PropertyMap stateNumToDbusProp = { |
| {PLDM_BOOT_PROGRESS_STATE, |
| {{PLDM_BOOT_NOT_ACTIVE, |
| "xyz.openbmc_project.State.OperatingSystem.Status.OSStatus." |
| "Standby"s}, |
| {PLDM_BOOT_COMPLETED, |
| "xyz.openbmc_project.State.OperatingSystem.Status.OSStatus." |
| "BootComplete"s}}}, |
| {PLDM_SYSTEM_POWER_STATE, |
| {{PLDM_OFF_SOFT_GRACEFUL, |
| "xyz.openbmc_project.State.Chassis.Transition.Off"s}}}}; |
| using namespace pldm::responder::pdr; |
| |
| state_effecter_possible_states* states = nullptr; |
| pldm_state_effecter_pdr* pdr = nullptr; |
| uint8_t compEffecterCnt = stateField.size(); |
| PdrEntry pdrEntry{}; |
| auto pdrRecord = pdrRepo.getFirstRecord(pdrEntry); |
| while (pdrRecord) |
| { |
| pdr = reinterpret_cast<pldm_state_effecter_pdr*>(pdrEntry.data); |
| if (pdr->effecter_id != effecterId) |
| { |
| pdr = nullptr; |
| pdrRecord = pdrRepo.getNextRecord(pdrRecord, pdrEntry); |
| continue; |
| } |
| |
| states = reinterpret_cast<state_effecter_possible_states*>( |
| pdr->possible_states); |
| if (compEffecterCnt > pdr->composite_effecter_count) |
| { |
| std::cerr << "The requester sent wrong composite effecter" |
| << " count for the effecter, EFFECTER_ID=" |
| << effecterId << "COMP_EFF_CNT=" << compEffecterCnt |
| << "\n"; |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| break; |
| } |
| |
| if (!pdr) |
| { |
| return PLDM_PLATFORM_INVALID_EFFECTER_ID; |
| } |
| |
| std::map<StateSetId, std::function<int(const std::string& objPath, |
| const uint8_t currState)>> |
| effecterToDbusEntries = { |
| {PLDM_BOOT_PROGRESS_STATE, |
| [&](const std::string& objPath, const uint8_t currState) { |
| auto stateSet = |
| stateNumToDbusProp.find(PLDM_BOOT_PROGRESS_STATE); |
| if (stateSet == stateNumToDbusProp.end()) |
| { |
| std::cerr << "Couldn't find D-Bus mapping for " |
| << "PLDM_BOOT_PROGRESS_STATE, EFFECTER_ID=" |
| << effecterId << "\n"; |
| return PLDM_ERROR; |
| } |
| auto iter = stateSet->second.find( |
| stateField[currState].effecter_state); |
| if (iter == stateSet->second.end()) |
| { |
| std::cerr << "Invalid state field passed or field not " |
| << "found for PLDM_BOOT_PROGRESS_STATE, " |
| "EFFECTER_ID=" |
| << effecterId << " FIELD=" |
| << stateField[currState].effecter_state |
| << " OBJECT_PATH=" << objPath.c_str() |
| << "\n"; |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| auto dbusProp = "OperatingSystemState"; |
| std::variant<std::string> value{ |
| std::get<std::string>(iter->second)}; |
| auto dbusInterface = |
| "xyz.openbmc_project.State.OperatingSystem.Status"; |
| try |
| { |
| dBusIntf.setDbusProperty(objPath.c_str(), dbusProp, |
| dbusInterface, value); |
| } |
| catch (const std::exception& e) |
| { |
| std::cerr |
| << "Error setting property, ERROR=" << e.what() |
| << " PROPERTY=" << dbusProp |
| << " INTERFACE=" << dbusInterface |
| << " PATH=" << objPath.c_str() << "\n"; |
| return PLDM_ERROR; |
| } |
| return PLDM_SUCCESS; |
| }}, |
| {PLDM_SYSTEM_POWER_STATE, |
| [&](const std::string& objPath, const uint8_t currState) { |
| auto stateSet = |
| stateNumToDbusProp.find(PLDM_SYSTEM_POWER_STATE); |
| if (stateSet == stateNumToDbusProp.end()) |
| { |
| std::cerr << "Couldn't find D-Bus mapping for " |
| << "PLDM_SYSTEM_POWER_STATE, EFFECTER_ID=" |
| << effecterId << "\n"; |
| return PLDM_ERROR; |
| } |
| auto iter = stateSet->second.find( |
| stateField[currState].effecter_state); |
| if (iter == stateSet->second.end()) |
| { |
| std::cerr << "Invalid state field passed or field not " |
| << "found for PLDM_SYSTEM_POWER_STATE, " |
| "EFFECTER_ID=" |
| << effecterId << " FIELD=" |
| << stateField[currState].effecter_state |
| << " OBJECT_PATH=" << objPath.c_str() |
| << "\n"; |
| return PLDM_ERROR_INVALID_DATA; |
| } |
| auto dbusProp = "RequestedPowerTransition"; |
| std::variant<std::string> value{ |
| std::get<std::string>(iter->second)}; |
| auto dbusInterface = "xyz.openbmc_project.State.Chassis"; |
| try |
| { |
| dBusIntf.setDbusProperty(objPath.c_str(), dbusProp, |
| dbusInterface, value); |
| } |
| catch (const std::exception& e) |
| { |
| std::cerr |
| << "Error setting property, ERROR=" << e.what() |
| << " PROPERTY=" << dbusProp |
| << " INTERFACE=" << dbusInterface |
| << " PATH=" << objPath.c_str() << "\n"; |
| return PLDM_ERROR; |
| } |
| return PLDM_SUCCESS; |
| }}}; |
| |
| int rc = PLDM_SUCCESS; |
| const auto& paths = getEffecterObjs(effecterId); |
| for (uint8_t currState = 0; currState < compEffecterCnt; ++currState) |
| { |
| std::vector<StateSetNum> allowed{}; |
| // computation is based on table 79 from DSP0248 v1.1.1 |
| uint8_t bitfieldIndex = stateField[currState].effecter_state / 8; |
| uint8_t bit = |
| stateField[currState].effecter_state - (8 * bitfieldIndex); |
| if (states->possible_states_size < bitfieldIndex || |
| !(states->states[bitfieldIndex].byte & (1 << bit))) |
| { |
| std::cerr << "Invalid state set value, EFFECTER_ID=" |
| << effecterId |
| << " VALUE=" << stateField[currState].effecter_state |
| << " COMPOSITE_EFFECTER_ID=" << currState |
| << " DBUS_PATH=" << paths[currState].c_str() << "\n"; |
| rc = PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE; |
| break; |
| } |
| auto iter = effecterToDbusEntries.find(states->state_set_id); |
| if (iter == effecterToDbusEntries.end()) |
| { |
| uint16_t setId = states->state_set_id; |
| std::cerr << "Did not find the state set for the" |
| << " state effecter pdr, STATE=" << setId |
| << " EFFECTER_ID=" << effecterId << "\n"; |
| rc = PLDM_PLATFORM_INVALID_STATE_VALUE; |
| break; |
| } |
| if (stateField[currState].set_request == PLDM_REQUEST_SET) |
| { |
| rc = iter->second(paths[currState], currState); |
| if (rc != PLDM_SUCCESS) |
| { |
| break; |
| } |
| } |
| uint8_t* nextState = |
| reinterpret_cast<uint8_t*>(states) + |
| sizeof(state_effecter_possible_states) - |
| sizeof(states->states) + |
| (states->possible_states_size * sizeof(states->states)); |
| states = |
| reinterpret_cast<state_effecter_possible_states*>(nextState); |
| } |
| return rc; |
| } |
| |
| private: |
| pdr_utils::Repo pdrRepo; |
| uint16_t nextEffecterId{}; |
| std::map<uint16_t, EffecterObjs> effecterObjs{}; |
| }; |
| |
| } // namespace platform |
| } // namespace responder |
| } // namespace pldm |