1 #pragma once 2 3 #include "libpldm/platform.h" 4 5 #include "common/types.hpp" 6 #include "numeric_sensor.hpp" 7 #include "requester/handler.hpp" 8 #include "terminus.hpp" 9 10 #include <sdbusplus/server/object.hpp> 11 #include <sdeventplus/event.hpp> 12 #include <xyz/openbmc_project/Inventory/Item/Board/server.hpp> 13 14 #include <algorithm> 15 #include <bitset> 16 #include <string> 17 #include <tuple> 18 #include <utility> 19 #include <vector> 20 21 namespace pldm 22 { 23 namespace platform_mc 24 { 25 26 using ContainerID = uint16_t; 27 using EntityInstanceNumber = uint16_t; 28 using EntityName = std::string; 29 using EntityType = uint16_t; 30 using SensorId = uint16_t; 31 using SensorCnt = uint8_t; 32 using NameLanguageTag = std::string; 33 using SensorName = std::string; 34 using SensorAuxiliaryNames = std::tuple< 35 SensorId, SensorCnt, 36 std::vector<std::vector<std::pair<NameLanguageTag, SensorName>>>>; 37 using InventoryItemBoardIntf = sdbusplus::server::object_t< 38 sdbusplus::xyz::openbmc_project::Inventory::Item::server::Board>; 39 40 /** @struct EntityKey 41 * 42 * EntityKey uniquely identifies the PLDM entity and a combination of Entity 43 * Type, Entity Instance Number, Entity Container ID 44 * 45 */ 46 struct EntityKey 47 { 48 EntityType type; //!< Entity type 49 EntityInstanceNumber instanceIdx; //!< Entity instance number 50 ContainerID containerId; //!< Entity container ID 51 52 bool operator==(const EntityKey& e) const 53 { 54 return ((type == e.type) && (instanceIdx == e.instanceIdx) && 55 (containerId == e.containerId)); 56 } 57 }; 58 59 using AuxiliaryNames = std::vector<std::pair<NameLanguageTag, std::string>>; 60 using EntityKey = struct EntityKey; 61 using EntityAuxiliaryNames = std::tuple<EntityKey, AuxiliaryNames>; 62 63 /** 64 * @brief Terminus 65 * 66 * Terminus class holds the TID, supported PLDM Type or PDRs which are needed by 67 * other manager class for sensor monitoring and control. 68 */ 69 class Terminus 70 { 71 public: 72 Terminus(pldm_tid_t tid, uint64_t supportedPLDMTypes); 73 74 /** @brief Check if the terminus supports the PLDM type message 75 * 76 * @param[in] type - PLDM Type 77 * @return support state - True if support, otherwise False 78 */ 79 bool doesSupportType(uint8_t type); 80 81 /** @brief Check if the terminus supports the PLDM command message 82 * 83 * @param[in] type - PLDM Type 84 * @param[in] command - PLDM command 85 * @return support state - True if support, otherwise False 86 */ 87 bool doesSupportCommand(uint8_t type, uint8_t command); 88 89 /** @brief Set the supported PLDM commands for terminus 90 * 91 * @param[in] cmds - bit mask of the supported PLDM commands 92 * @return success state - True if success, otherwise False 93 */ 94 bool setSupportedCommands(const std::vector<uint8_t>& cmds) 95 { 96 const size_t expectedSize = 97 PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8); 98 if (cmds.empty() || cmds.size() != expectedSize) 99 { 100 lg2::error( 101 "setSupportedCommands received invalid bit mask size. Expected: {EXPECTED}, Received: {RECEIVED}", 102 "EXPECTED", expectedSize, "RECEIVED", cmds.size()); 103 return false; 104 } 105 106 /* Assign Vector supportedCmds by Vector cmds */ 107 supportedCmds.resize(cmds.size()); 108 std::copy(cmds.begin(), cmds.begin() + cmds.size(), 109 supportedCmds.begin()); 110 111 return true; 112 } 113 114 /** @brief Parse the PDRs stored in the member variable, pdrs. 115 */ 116 void parseTerminusPDRs(); 117 118 /** @brief The getter to return terminus's TID */ 119 pldm_tid_t getTid() 120 { 121 return tid; 122 } 123 124 /** @brief The getter to get terminus's mctp medium */ 125 std::optional<std::string_view> getTerminusName() 126 { 127 if (terminusName.empty()) 128 { 129 return std::nullopt; 130 } 131 return terminusName; 132 } 133 134 /** @brief A list of PDRs fetched from Terminus */ 135 std::vector<std::vector<uint8_t>> pdrs{}; 136 137 /** @brief A flag to indicate if terminus has been initialized */ 138 bool initialized = false; 139 140 /** @brief maximum message buffer size the terminus can send and receive */ 141 uint16_t maxBufferSize; 142 143 /** @brief This value indicates the event messaging styles supported by the 144 * terminus 145 */ 146 bitfield8_t synchronyConfigurationSupported; 147 148 /** @brief A list of numericSensors */ 149 std::vector<std::shared_ptr<NumericSensor>> numericSensors{}; 150 151 /** @brief Get Sensor Auxiliary Names by sensorID 152 * 153 * @param[in] id - sensor ID 154 * @return sensor auxiliary names 155 */ 156 std::shared_ptr<SensorAuxiliaryNames> getSensorAuxiliaryNames(SensorId id); 157 158 /** @brief Get Numeric Sensor Object by sensorID 159 * 160 * @param[in] id - sensor ID 161 * 162 * @return sensor object 163 */ 164 std::shared_ptr<NumericSensor> getSensorObject(SensorId id); 165 166 private: 167 /** @brief Find the Terminus Name from the Entity Auxiliary name list 168 * The Entity Auxiliary name list is entityAuxiliaryNamesTbl. 169 * @return terminus name in string option 170 */ 171 std::optional<std::string_view> findTerminusName(); 172 173 /** @brief Construct the NumericSensor sensor class for the PLDM sensor. 174 * The NumericSensor class will handle create D-Bus object path, 175 * provide the APIs to update sensor value, threshold... 176 * 177 * @param[in] pdr - the numeric sensor PDR info 178 */ 179 void addNumericSensor( 180 const std::shared_ptr<pldm_numeric_sensor_value_pdr> pdr); 181 182 /** @brief Parse the numeric sensor PDRs 183 * 184 * @param[in] pdrData - the response PDRs from GetPDR command 185 * @return pointer to numeric sensor info struct 186 */ 187 std::shared_ptr<pldm_numeric_sensor_value_pdr> 188 parseNumericSensorPDR(const std::vector<uint8_t>& pdrData); 189 190 /** @brief Parse the sensor Auxiliary name PDRs 191 * 192 * @param[in] pdrData - the response PDRs from GetPDR command 193 * @return pointer to sensor Auxiliary name info struct 194 */ 195 std::shared_ptr<SensorAuxiliaryNames> 196 parseSensorAuxiliaryNamesPDR(const std::vector<uint8_t>& pdrData); 197 198 /** @brief Parse the Entity Auxiliary name PDRs 199 * 200 * @param[in] pdrData - the response PDRs from GetPDR command 201 * @return pointer to Entity Auxiliary name info struct 202 */ 203 std::shared_ptr<EntityAuxiliaryNames> 204 parseEntityAuxiliaryNamesPDR(const std::vector<uint8_t>& pdrData); 205 206 /** @brief Construct the NumericSensor sensor class for the compact numeric 207 * PLDM sensor. 208 * 209 * @param[in] pdr - the compact numeric sensor PDR info 210 */ 211 void addCompactNumericSensor( 212 const std::shared_ptr<pldm_compact_numeric_sensor_pdr> pdr); 213 214 /** @brief Parse the compact numeric sensor PDRs 215 * 216 * @param[in] pdrData - the response PDRs from GetPDR command 217 * @return pointer to compact numeric sensor info struct 218 */ 219 std::shared_ptr<pldm_compact_numeric_sensor_pdr> 220 parseCompactNumericSensorPDR(const std::vector<uint8_t>& pdrData); 221 222 /** @brief Parse the sensor Auxiliary name from compact numeric sensor PDRs 223 * 224 * @param[in] pdrData - the response PDRs from GetPDR command 225 * @return pointer to sensor Auxiliary name info struct 226 */ 227 std::shared_ptr<SensorAuxiliaryNames> 228 parseCompactNumericSensorNames(const std::vector<uint8_t>& pdrData); 229 230 /** @brief Create the terminus inventory path to 231 * /xyz/openbmc_project/inventory/Item/Board/. 232 * 233 * @param[in] tName - the terminus name 234 * @return true/false: True if there is no error in creating inventory path 235 * 236 */ 237 bool createInventoryPath(std::string tName); 238 239 /* @brief The terminus's TID */ 240 pldm_tid_t tid; 241 242 /* @brief The supported PLDM command types of the terminus */ 243 std::bitset<64> supportedTypes; 244 245 /** @brief Store supported PLDM commands of a terminus 246 * Maximum number of PLDM Type is PLDM_MAX_TYPES 247 * Maximum number of PLDM command for each type is 248 * PLDM_MAX_CMDS_PER_TYPE. 249 * Each uint8_t can store the supported state of 8 PLDM commands. 250 * Size of supportedCmds will be 251 * PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8). 252 */ 253 std::vector<uint8_t> supportedCmds; 254 255 /* @brief Sensor Auxiliary Name list */ 256 std::vector<std::shared_ptr<SensorAuxiliaryNames>> 257 sensorAuxiliaryNamesTbl{}; 258 259 /* @brief Entity Auxiliary Name list */ 260 std::vector<std::shared_ptr<EntityAuxiliaryNames>> 261 entityAuxiliaryNamesTbl{}; 262 263 /** @brief Terminus name */ 264 EntityName terminusName{}; 265 /* @brief The pointer of iventory D-Bus interface for the terminus */ 266 std::unique_ptr<InventoryItemBoardIntf> inventoryItemBoardInft = nullptr; 267 268 /* @brief Inventory D-Bus object path of the terminus */ 269 std::string inventoryPath; 270 }; 271 } // namespace platform_mc 272 } // namespace pldm 273