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 "utils.hpp" 9 10 #include <org/open_power/Control/Host/server.hpp> 11 #include <org/open_power/OCC/Status/server.hpp> 12 #include <sdbusplus/bus.hpp> 13 #include <sdbusplus/server/object.hpp> 14 15 #include <functional> 16 17 namespace open_power 18 { 19 namespace occ 20 { 21 22 class Manager; 23 namespace Base = sdbusplus::org::open_power::OCC::server; 24 using Interface = sdbusplus::server::object::object<Base::Status>; 25 26 // IPMID's host control application 27 namespace Control = sdbusplus::org::open_power::Control::server; 28 29 // For waiting on signals 30 namespace sdbusRule = sdbusplus::bus::match::rules; 31 32 // OCC status instance. Ex. for "occ0", the instance is 0 33 using instanceID = int; 34 35 // IPMI sensor ID for a given OCC instance 36 using sensorID = uint8_t; 37 38 // Human readable sensor name for DBus tree. E.g. "CPU0_OCC" 39 using sensorName = std::string; 40 41 // OCC sensors definitions in the map 42 using sensorDefs = std::tuple<sensorID, sensorName>; 43 44 // OCC sysfs name prefix 45 const std::string sysfsName = "occ-hwmon"; 46 47 /** @class Status 48 * @brief Implementation of OCC Active Status 49 */ 50 class Status : public Interface 51 { 52 public: 53 Status() = delete; 54 ~Status() = default; 55 Status(const Status&) = delete; 56 Status& operator=(const Status&) = delete; 57 Status(Status&&) = default; 58 Status& operator=(Status&&) = default; 59 60 /** @brief Constructs the Status object and 61 * the underlying device object 62 * 63 * @param[in] event - sd_event unique pointer reference 64 * @param[in] path - DBus object path 65 * @param[in] manager - OCC manager instance 66 * @param[in] callBack - Callback handler to invoke during 67 * property change 68 * @param[in] resetCallBack - callback handler to invoke for resetting the 69 * OCC if PLDM is the host communication 70 * protocol 71 */ 72 Status(EventPtr& event, const char* path, const Manager& manager, 73 std::function<void(bool)> callBack = nullptr 74 #ifdef PLDM 75 , 76 std::function<void(instanceID)> resetCallBack = nullptr 77 #endif 78 ) : 79 80 Interface(utils::getBus(), getDbusPath(path).c_str(), true), 81 path(path), callBack(callBack), instance(getInstance(path)), 82 device(event, 83 #ifdef I2C_OCC 84 fs::path(DEV_PATH) / i2c_occ::getI2cDeviceName(path), 85 #else 86 fs::path(DEV_PATH) / 87 fs::path(sysfsName + "." + std::to_string(instance + 1)), 88 #endif 89 manager, *this, 90 std::bind(std::mem_fn(&Status::deviceErrorHandler), this, 91 std::placeholders::_1)), 92 hostControlSignal( 93 utils::getBus(), 94 sdbusRule::type::signal() + sdbusRule::member("CommandComplete") + 95 sdbusRule::path("/org/open_power/control/host0") + 96 sdbusRule::interface("org.open_power.Control.Host") + 97 sdbusRule::argN(0, Control::convertForMessage( 98 Control::Host::Command::OCCReset)), 99 std::bind(std::mem_fn(&Status::hostControlEvent), this, 100 std::placeholders::_1)), 101 occCmd(instance, (fs::path(OCC_CONTROL_ROOT) / 102 (std::string(OCC_NAME) + std::to_string(instance))) 103 .c_str()) 104 #ifdef PLDM 105 , 106 resetCallBack(resetCallBack) 107 #endif 108 { 109 // Check to see if we have OCC already bound. If so, just set it 110 if (device.bound()) 111 { 112 this->occActive(true); 113 } 114 115 // Announce that we are ready 116 this->emit_object_added(); 117 } 118 119 /** @brief Since we are overriding the setter-occActive but not the 120 * getter-occActive, we need to have this using in order to 121 * allow passthrough usage of the getter-occActive 122 */ 123 using Base::Status::occActive; 124 125 /** @brief SET OccActive to True or False 126 * 127 * @param[in] value - Intended value 128 * 129 * @return - Updated value of the property 130 */ 131 bool occActive(bool value) override; 132 133 /** @brief Starts OCC error detection */ 134 inline void addErrorWatch() 135 { 136 return device.addErrorWatch(); 137 } 138 139 /** @brief Stops OCC error detection */ 140 inline void removeErrorWatch() 141 { 142 return device.removeErrorWatch(); 143 } 144 145 /** @brief Starts to watch how many OCCs are present on the master */ 146 inline void addPresenceWatchMaster() 147 { 148 return device.addPresenceWatchMaster(); 149 } 150 151 /** @brief Gets the occ instance number */ 152 unsigned int getOccInstanceID() 153 { 154 return instance; 155 } 156 157 /** @brief Is this OCC the master OCC */ 158 bool isMasterOcc() 159 { 160 return device.master(); 161 } 162 163 /** @brief Read OCC state (will trigger kernel to poll the OCC) */ 164 void readOccState(); 165 166 #ifdef POWER10 167 /** @brief Handle additional tasks when the OCCs reach active state */ 168 void occsWentActive(); 169 170 /** @brief Send mode change command to the master OCC 171 * @return SUCCESS on success 172 */ 173 CmdStatus sendModeChange(); 174 175 /** @brief Send Idle Power Saver config data to the master OCC 176 * @return SUCCESS on success 177 */ 178 CmdStatus sendIpsData(); 179 #endif // POWER10 180 181 private: 182 /** @brief OCC dbus object path */ 183 std::string path; 184 185 /** @brief Callback handler to be invoked during property change. 186 * This is a handler in Manager class 187 */ 188 std::function<void(bool)> callBack; 189 190 /** @brief OCC instance number. Ex, 0,1, etc */ 191 unsigned int instance; 192 193 /** @brief The last state read from the OCC */ 194 unsigned int lastState = 0; 195 196 /** @brief OCC instance to Sensor definitions mapping */ 197 static const std::map<instanceID, sensorDefs> sensorMap; 198 199 /** @brief OCC device object to do bind and unbind */ 200 Device device; 201 202 /** @brief Subscribe to host control signal 203 * 204 * Once the OCC reset is requested, BMC sends that message to host. 205 * If the host does not ack the message, then there would be a timeout 206 * and we need to catch that to log an error 207 **/ 208 sdbusplus::bus::match_t hostControlSignal; 209 210 /** @brief Command object to send commands to the OCC */ 211 OccCommand occCmd; 212 213 /** @brief Callback handler when device errors are detected 214 * 215 * @param[in] error - True if an error is reported, false otherwise 216 */ 217 void deviceErrorHandler(bool error); 218 219 /** @brief Callback function on host control signals 220 * 221 * @param[in] msg - Data associated with subscribed signal 222 */ 223 void hostControlEvent(sdbusplus::message::message& msg); 224 225 /** @brief Sends a message to host control command handler to reset OCC 226 */ 227 void resetOCC(); 228 229 /** @brief Determines the instance ID by specified object path. 230 * @param[in] path Estimated OCC Dbus object path 231 * @return Instance number 232 */ 233 static int getInstance(const std::string& path) 234 { 235 return (path.empty() ? 0 : path.back() - '0'); 236 } 237 238 #ifdef POWER10 239 /** @brief Query the current Hypervisor target 240 * @return true if the current Hypervisor target is PowerVM 241 */ 242 bool isPowerVM(); 243 244 /** @brief Get the requested power mode property 245 * @return Power mode 246 */ 247 SysPwrMode getMode(); 248 249 /** @brief Get the Idle Power Saver properties 250 * @return true if IPS is enabled 251 */ 252 bool getIPSParms(uint8_t& enterUtil, uint16_t& enterTime, uint8_t& exitUtil, 253 uint16_t& exitTime); 254 #endif // POWER10 255 256 /** @brief Override the sensor name with name from the definition. 257 * @param[in] estimatedPath - Estimated OCC Dbus object path 258 * @return Fixed OCC DBus object path 259 */ 260 static std::string getDbusPath(const std::string& estimatedPath) 261 { 262 if (!estimatedPath.empty()) 263 { 264 auto it = sensorMap.find(getInstance(estimatedPath)); 265 if (sensorMap.end() != it) 266 { 267 auto& name = std::get<1>(it->second); 268 if (!name.empty() && name != "None") 269 { 270 auto path = fs::path(estimatedPath); 271 path.replace_filename(name); 272 return path.string(); 273 } 274 } 275 } 276 277 return estimatedPath; 278 } 279 #ifdef PLDM 280 std::function<void(instanceID)> resetCallBack = nullptr; 281 #endif 282 }; 283 284 } // namespace occ 285 } // namespace open_power 286