1 #pragma once 2 #include "config.h" 3 4 #include "i2c_occ.hpp" 5 #include "occ_command.hpp" 6 #include "occ_device.hpp" 7 #include "occ_events.hpp" 8 #include "powercap.hpp" 9 #include "powermode.hpp" 10 #include "utils.hpp" 11 12 #include <org/open_power/Control/Host/server.hpp> 13 #include <org/open_power/OCC/Status/server.hpp> 14 #include <sdbusplus/bus.hpp> 15 #include <sdbusplus/server/object.hpp> 16 #ifdef POWER10 17 #include <sdeventplus/event.hpp> 18 #include <sdeventplus/utility/timer.hpp> 19 #endif 20 21 #include <functional> 22 23 namespace open_power 24 { 25 namespace occ 26 { 27 28 class Manager; 29 namespace Base = sdbusplus::org::open_power::OCC::server; 30 using Interface = sdbusplus::server::object_t<Base::Status>; 31 32 // IPMID's host control application 33 namespace Control = sdbusplus::org::open_power::Control::server; 34 35 // For waiting on signals 36 namespace sdbusRule = sdbusplus::bus::match::rules; 37 38 // OCC status instance. Ex. for "occ0", the instance is 0 39 using instanceID = unsigned int; 40 41 // IPMI sensor ID for a given OCC instance 42 using sensorID = uint8_t; 43 44 // Human readable sensor name for DBus tree. E.g. "CPU0_OCC" 45 using sensorName = std::string; 46 47 // OCC sensors definitions in the map 48 using sensorDefs = std::tuple<sensorID, sensorName>; 49 50 // OCC sysfs name prefix 51 const std::string sysfsName = "occ-hwmon"; 52 53 /** @class Status 54 * @brief Implementation of OCC Active Status 55 */ 56 class Status : public Interface 57 { 58 public: 59 Status() = delete; 60 ~Status() = default; 61 Status(const Status&) = delete; 62 Status& operator=(const Status&) = delete; 63 Status(Status&&) = default; 64 Status& operator=(Status&&) = default; 65 66 /** @brief Constructs the Status object and 67 * the underlying device object 68 * 69 * @param[in] event - sd_event unique pointer reference 70 * @param[in] path - DBus object path 71 * @param[in] manager - OCC manager instance 72 * @param[in] callBack - Callback handler to invoke during 73 * property change 74 * @param[in] resetCallBack - callback handler to invoke for resetting the 75 * OCC if PLDM is the host communication 76 * protocol 77 */ 78 Status(EventPtr& event, const char* path, Manager& managerRef, 79 #ifdef POWER10 80 std::unique_ptr<powermode::PowerMode>& powerModeRef, 81 #endif 82 std::function<void(instanceID, bool)> callBack = nullptr 83 #ifdef PLDM 84 , 85 std::function<void(instanceID)> resetCallBack = nullptr 86 #endif 87 ) : 88 89 Interface(utils::getBus(), getDbusPath(path).c_str(), 90 Interface::action::defer_emit), 91 path(path), managerCallBack(callBack), instance(getInstance(path)), 92 manager(managerRef), 93 #ifdef POWER10 94 pmode(powerModeRef), 95 #endif 96 device(event, 97 #ifdef I2C_OCC 98 fs::path(DEV_PATH) / i2c_occ::getI2cDeviceName(path), 99 #else 100 fs::path(DEV_PATH) / 101 fs::path(sysfsName + "." + std::to_string(instance + 1)), 102 #endif 103 managerRef, *this, 104 #ifdef POWER10 105 powerModeRef, 106 #endif 107 instance), 108 hostControlSignal( 109 utils::getBus(), 110 sdbusRule::type::signal() + sdbusRule::member("CommandComplete") + 111 sdbusRule::path("/org/open_power/control/host0") + 112 sdbusRule::interface("org.open_power.Control.Host") + 113 sdbusRule::argN(0, Control::convertForMessage( 114 Control::Host::Command::OCCReset)), 115 std::bind(std::mem_fn(&Status::hostControlEvent), this, 116 std::placeholders::_1)), 117 occCmd(instance, (fs::path(OCC_CONTROL_ROOT) / 118 (std::string(OCC_NAME) + std::to_string(instance))) 119 .c_str()) 120 #ifdef POWER10 121 , 122 sdpEvent(sdeventplus::Event::get_default()), 123 safeStateDelayTimer( 124 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>( 125 sdpEvent, std::bind(&Status::safeStateDelayExpired, this))), 126 occReadStateFailTimer( 127 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>( 128 sdpEvent, std::bind(&Status::occReadStateNow, this))) 129 #endif 130 131 #ifdef PLDM 132 , 133 resetCallBack(resetCallBack) 134 #endif 135 { 136 // Announce that we are ready 137 this->emit_object_added(); 138 } 139 140 /** @brief Since we are overriding the setter-occActive but not the 141 * getter-occActive, we need to have this using in order to 142 * allow passthrough usage of the getter-occActive 143 */ 144 using Base::Status::occActive; 145 146 /** @brief SET OccActive to True or False 147 * 148 * @param[in] value - Intended value 149 * 150 * @return - Updated value of the property 151 */ 152 bool occActive(bool value) override; 153 154 /** @brief Starts OCC error detection */ 155 inline void addErrorWatch() 156 { 157 return device.addErrorWatch(); 158 } 159 160 /** @brief Stops OCC error detection */ 161 inline void removeErrorWatch() 162 { 163 return device.removeErrorWatch(); 164 } 165 166 /** @brief Starts to watch how many OCCs are present on the master */ 167 inline void addPresenceWatchMaster() 168 { 169 return device.addPresenceWatchMaster(); 170 } 171 172 /** @brief Gets the occ instance number */ 173 unsigned int getOccInstanceID() 174 { 175 return instance; 176 } 177 178 /** @brief Is this OCC the master OCC */ 179 bool isMasterOcc() 180 { 181 return device.master(); 182 } 183 184 /** @brief Read OCC state (will trigger kernel to poll the OCC) */ 185 void readOccState(); 186 187 /** @brief Called when device errors are detected 188 * 189 * @param[in] d - description of the error that occurred 190 */ 191 void deviceError(Error::Descriptor d = Error::Descriptor()); 192 193 #ifdef POWER10 194 /** @brief Handle additional tasks when the OCCs reach active state */ 195 void occsWentActive(); 196 197 /** @brief Send Ambient & Altitude data to OCC 198 * 199 * @param[in] ambient - temperature to send (0xFF will force read 200 * of current temperature and altitude) 201 * @param[in] altitude - altitude to send (0xFFFF = unavailable) 202 * 203 * @return SUCCESS on success 204 */ 205 CmdStatus sendAmbient(const uint8_t ambient = 0xFF, 206 const uint16_t altitude = 0xFFFF); 207 208 /** @brief Set flag indicating if PLDM sensor has been received 209 * 210 * @param[in] wasReceived - true if PLDM sensor was read 211 */ 212 void setPldmSensorReceived(const bool wasReceived) 213 { 214 pldmSensorStateReceived = wasReceived; 215 } 216 217 /** @brief Read flag indicating if PLDM sensor has been read 218 * 219 * @return true if sensor has been read 220 */ 221 bool getPldmSensorReceived() 222 { 223 return pldmSensorStateReceived; 224 } 225 226 #endif // POWER10 227 228 /** @brief Return the HWMON path for this OCC 229 * 230 * @return path or empty path if not found 231 */ 232 fs::path getHwmonPath(); 233 234 private: 235 /** @brief OCC dbus object path */ 236 std::string path; 237 238 /** @brief Callback handler to be invoked during property change. 239 * This is a handler in Manager class 240 */ 241 std::function<void(instanceID, bool)> managerCallBack; 242 243 /** @brief OCC instance number. Ex, 0,1, etc */ 244 unsigned int instance; 245 246 /** @brief The last state read from the OCC */ 247 unsigned int lastState = 0; 248 249 /** @brief Number of retry attempts to open file and update state. */ 250 const unsigned int occReadRetries = 1; 251 252 /** @brief Current number of retries attempted towards occReadRetries. */ 253 size_t currentOccReadRetriesCount = 0; 254 255 /** @brief The Trigger to indicate OCC State is valid or not. */ 256 bool stateValid = false; 257 258 /** @brief OCC instance to Sensor definitions mapping */ 259 static const std::map<instanceID, sensorDefs> sensorMap; 260 261 /** @brief OCC manager object */ 262 const Manager& manager; 263 264 #ifdef POWER10 265 /** @brief OCC PowerMode object */ 266 std::unique_ptr<powermode::PowerMode>& pmode; 267 #endif 268 269 /** @brief OCC device object to do bind and unbind */ 270 Device device; 271 272 /** @brief Subscribe to host control signal 273 * 274 * Once the OCC reset is requested, BMC sends that message to host. 275 * If the host does not ack the message, then there would be a timeout 276 * and we need to catch that to log an error 277 **/ 278 sdbusplus::bus::match_t hostControlSignal; 279 280 /** @brief Command object to send commands to the OCC */ 281 OccCommand occCmd; 282 283 #ifdef POWER10 284 /** @brief timer event */ 285 sdeventplus::Event sdpEvent; 286 #endif 287 288 /** @brief hwmon path for this OCC */ 289 fs::path hwmonPath; 290 291 /** @brief flag indicating if the OCC sensor has been received */ 292 bool pldmSensorStateReceived = false; 293 294 /** @brief Callback function on host control signals 295 * 296 * @param[in] msg - Data associated with subscribed signal 297 */ 298 void hostControlEvent(sdbusplus::message_t& msg); 299 300 /** @brief Sends a message to host control command handler to reset OCC 301 */ 302 void resetOCC(); 303 304 /** @brief Determines the instance ID by specified object path. 305 * @param[in] path Estimated OCC Dbus object path 306 * @return Instance number 307 */ 308 static int getInstance(const std::string& path) 309 { 310 return (path.empty() ? 0 : path.back() - '0'); 311 } 312 313 #ifdef POWER10 314 /** 315 * @brief Timer that is started when OCC is detected to be in safe mode 316 */ 317 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic> 318 safeStateDelayTimer; 319 320 /** @brief Callback for timer that is started when OCC was detected to be in 321 * safe mode. Called to verify and then disable and reset the OCCs. 322 */ 323 void safeStateDelayExpired(); 324 325 /** 326 * @brief Timer that is started when OCC read Valid state failed. 327 */ 328 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic> 329 occReadStateFailTimer; 330 331 #endif // POWER10 332 /** @brief Callback for timer that is started when OCC state 333 * was not able to be read. Called to attempt another read when needed. 334 */ 335 void occReadStateNow(); 336 337 /** @brief Override the sensor name with name from the definition. 338 * @param[in] estimatedPath - Estimated OCC Dbus object path 339 * @return Fixed OCC DBus object path 340 */ 341 static std::string getDbusPath(const std::string& estimatedPath) 342 { 343 if (!estimatedPath.empty()) 344 { 345 auto it = sensorMap.find(getInstance(estimatedPath)); 346 if (sensorMap.end() != it) 347 { 348 auto& name = std::get<1>(it->second); 349 if (!name.empty() && name != "None") 350 { 351 auto objectPath = fs::path(estimatedPath); 352 objectPath.replace_filename(name); 353 return objectPath.string(); 354 } 355 } 356 } 357 358 return estimatedPath; 359 } 360 #ifdef PLDM 361 std::function<void(instanceID)> resetCallBack = nullptr; 362 #endif 363 }; 364 365 } // namespace occ 366 } // namespace open_power 367