1 /** 2 * Copyright © 2020 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #pragma once 17 18 #include "config_base.hpp" 19 #include "dbus_zone.hpp" 20 #include "fan.hpp" 21 22 #include <nlohmann/json.hpp> 23 #include <sdeventplus/event.hpp> 24 #include <sdeventplus/utility/timer.hpp> 25 26 #include <any> 27 #include <chrono> 28 #include <functional> 29 #include <map> 30 #include <memory> 31 #include <tuple> 32 33 namespace phosphor::fan::control::json 34 { 35 36 class Manager; 37 38 using json = nlohmann::json; 39 40 /* Dbus event timer */ 41 using Timer = sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>; 42 43 /** 44 * @class Zone - Represents a configured fan control zone 45 * 46 * A zone object contains the configured attributes for a zone that groups 47 * a number of fans together to be under the same target control. These 48 * configuration attributes include, but are not limited to, the default ceiling 49 * of the fans within the zone, a default floor, the delay between increases, a 50 * decrease interval, and any profiles(OPTIONAL) the zone should be included in. 51 * 52 * (When no profile for a zone is given, the zone defaults to always exist) 53 * 54 */ 55 class Zone : public ConfigBase 56 { 57 public: 58 /* JSON file name for zones */ 59 static constexpr auto confFileName = "zones.json"; 60 61 Zone() = delete; 62 Zone(const Zone&) = delete; 63 Zone(Zone&&) = delete; 64 Zone& operator=(const Zone&) = delete; 65 Zone& operator=(Zone&&) = delete; 66 ~Zone() = default; 67 68 /** 69 * Constructor 70 * Parses and populates a zone from JSON object data 71 * 72 * @param[in] jsonObj - JSON object 73 * @param[in] event - sdeventplus event loop 74 * @param[in] mgr - Manager of this zone 75 */ 76 Zone(const json& jsonObj, const sdeventplus::Event& event, Manager* mgr); 77 78 /** 79 * @brief Get the poweron target 80 * 81 * Poweron target is the target the fans within this zone should be set to 82 * when the system is powered on. 83 * 84 * @return Poweron target of this zone 85 */ 86 inline const auto& getPoweronTarget() const 87 { 88 return _poweronTarget; 89 } 90 91 /** 92 * @brief Get the default ceiling 93 * 94 * Default ceiling is the highest target the fans within this zone is 95 * allowed to increase to. The zone's ceiling defaults to this unless 96 * changed by some configured event. 97 * 98 * @return Default ceiling of this zone 99 */ 100 inline const auto& getDefaultCeiling() const 101 { 102 return _defaultCeiling; 103 } 104 105 /** 106 * @brief Get the default floor 107 * 108 * The default floor is the lowest target the fans within this zone 109 * are allowed to decrease to. The zone's floor defaults to this 110 * unless changed by some configured event. 111 * 112 * @return Default floor 113 */ 114 inline const auto& getDefaultFloor() const 115 { 116 return _defaultFloor; 117 } 118 119 /** 120 * @brief Get the increase delay(OPTIONAL) 121 * 122 * The increase delay is the amount of time(in seconds) increases 123 * to a target are delayed before being made. The default is 0, which 124 * results in immediate increase requests when any events result in 125 * a change to the target. 126 * 127 * It is recommend a value other than 0 is configured, but that inherently 128 * depends on the fan controller and configured increases. 129 * 130 * @return Increase delay(in seconds) 131 */ 132 inline const auto& getIncDelay() const 133 { 134 return _incDelay; 135 } 136 137 /** 138 * @brief Get the decrease interval 139 * 140 * Decreases happen on a set interval when no requests for an increase 141 * in fan targets exists. This is the interval(in seconds) at which the fans 142 * within the zone are decreased if events exist that result in a target 143 * decrease. 144 * 145 * @return Decrease interval(in seconds) 146 */ 147 inline const auto& getDecInterval() const 148 { 149 return _decInterval; 150 } 151 152 /** 153 * @brief Get the current target of the zone 154 * 155 * @return - The current target of the zone 156 */ 157 inline const auto& getTarget() const 158 { 159 return _target; 160 } 161 162 /** 163 * @brief Get the target increase delta 164 * 165 * @return - The current target increase delta 166 */ 167 inline auto& getIncDelta() const 168 { 169 return _incDelta; 170 }; 171 172 /** 173 * @brief Get the target decrease delta 174 * 175 * @return - The current target decrease delta 176 */ 177 inline auto& getDecDelta() const 178 { 179 return _decDelta; 180 }; 181 182 /** 183 * @brief Get the manager of the zone 184 * 185 * @return - The manager of the zone 186 */ 187 inline auto* getManager() const 188 { 189 return _manager; 190 } 191 192 /** 193 * @brief Enable the zone 194 * 195 * Performs the necessary tasks to enable the zone such as restoring any 196 * dbus property states(if persisted), starting the decrement timer, etc... 197 */ 198 void enable(); 199 200 /** 201 * @brief Add a fan object to the zone 202 * 203 * @param[in] fan - Unique pointer to a fan object that will be moved into 204 * the zone 205 * 206 * Adds a fan object to the list of fans that make up the zone by moving the 207 * fan object into the list. 208 */ 209 void addFan(std::unique_ptr<Fan> fan); 210 211 /** 212 * Sets all fans in the zone to the target given when the zone is active 213 * 214 * @param[in] target - Target for fans 215 */ 216 void setTarget(uint64_t target); 217 218 /** 219 * @brief Sets the automatic fan control allowed active state 220 * 221 * @param[in] ident - An identifier that affects the active state 222 * @param[in] isActiveAllow - Active state according to group 223 */ 224 void setActiveAllow(const std::string& ident, bool isActiveAllow); 225 226 /** 227 * @brief Set the floor to the given target and increase target to the floor 228 * when the target is below the floor value when floor changes are allowed. 229 * 230 * @param[in] target - Target to set the floor to 231 */ 232 void setFloor(uint64_t target); 233 234 /** 235 * @brief Sets the floor change allowed state 236 * 237 * @param[in] ident - An identifier that affects floor changes 238 * @param[in] isAllow - Allow state according to the identifier 239 */ 240 inline void setFloorChangeAllow(const std::string& ident, bool isAllow) 241 { 242 _floorChange[ident] = isAllow; 243 } 244 245 /** 246 * @brief Sets the decrease allowed state of a group 247 * 248 * @param[in] ident - An identifier that affects speed decreases 249 * @param[in] isAllow - Allow state according to the identifier 250 */ 251 inline void setDecreaseAllow(const std::string& ident, bool isAllow) 252 { 253 _decAllowed[ident] = isAllow; 254 } 255 256 /** 257 * @brief Calculate the requested target from the given delta and increases 258 * the fans, not going above the ceiling. 259 * 260 * @param[in] targetDelta - The delta to increase the target by 261 */ 262 void requestIncrease(uint64_t targetDelta); 263 264 /** 265 * @brief Callback function for the increase timer that delays 266 * processing of requested target increases while fans are increasing 267 */ 268 void incTimerExpired(); 269 270 /** 271 * @brief Calculate the lowest requested decrease target from the given 272 * delta within a decrease interval. 273 * 274 * @param[in] targetDelta - The delta to decrease the target by 275 */ 276 void requestDecrease(uint64_t targetDelta); 277 278 /** 279 * @brief Callback function for the decrease timer that processes any 280 * requested target decreases if allowed 281 */ 282 void decTimerExpired(); 283 284 /** 285 * @brief Set the requested target base to be used as the target to base a 286 * new requested target from 287 * 288 * @param[in] targetBase - Base target value to use 289 */ 290 inline void setRequestTargetBase(uint64_t targetBase) 291 { 292 _requestTargetBase = targetBase; 293 }; 294 295 /** 296 * @brief Set a property to be persisted 297 * 298 * @param[in] intf - Interface containing property 299 * @param[in] prop - Property to be persisted 300 */ 301 void setPersisted(const std::string& intf, const std::string& prop); 302 303 /** 304 * @brief Is the property persisted 305 * 306 * @param[in] intf - Interface containing property 307 * @param[in] prop - Property to check if persisted 308 * 309 * @return - True if property is to be persisted, false otherwise 310 */ 311 bool isPersisted(const std::string& intf, const std::string& prop) const; 312 313 /** 314 * @brief A handler function to set/update a property on a zone 315 * @details Sets or updates a zone's dbus property to the given value using 316 * the provided base dbus object's set property function 317 * 318 * @param[in] intf - Interface on zone object 319 * @param[in] prop - Property on interface 320 * @param[in] func - Zone dbus object's set property function pointer 321 * @param[in] value - Value to set property to 322 * @param[in] persist - Persist property value or not 323 * 324 * @return Lambda function 325 * A lambda function to set/update the zone dbus object's property 326 */ 327 template <typename T> 328 static auto setProperty(const char* intf, const char* prop, 329 T (DBusZone::*func)(T), T&& value, bool persist) 330 { 331 return [=, value = std::forward<T>(value)](DBusZone& dbusZone, 332 Zone& zone) { 333 (dbusZone.*func)(value); 334 if (persist) 335 { 336 zone.setPersisted(intf, prop); 337 } 338 }; 339 } 340 341 /** 342 * @brief A handler function to set/update a zone's dbus property's persist 343 * state 344 * @details Sets or updates a zone's dbus property's persist state where the 345 * value of the property is to be left unchanged 346 * 347 * @param[in] intf - Interface on zone object 348 * @param[in] prop - Property on interface 349 * @param[in] persist - Persist property value or not 350 * 351 * @return Lambda function 352 * A lambda function to set/update the zone's dbus object's property's 353 * persist state 354 */ 355 static auto setPropertyPersist(const char* intf, const char* prop, 356 bool persist) 357 { 358 return [=](DBusZone&, Zone& zone) { 359 if (persist) 360 { 361 zone.setPersisted(intf, prop); 362 } 363 }; 364 } 365 366 private: 367 /* The zone's associated dbus object */ 368 std::unique_ptr<DBusZone> _dbusZone; 369 370 /* The zone's manager */ 371 Manager* _manager; 372 373 /* The zone's poweron target value for fans */ 374 uint64_t _poweronTarget; 375 376 /* The zone's default ceiling value for fans */ 377 uint64_t _defaultCeiling; 378 379 /* The zone's default floor value for fans */ 380 uint64_t _defaultFloor; 381 382 /* Zone's increase delay(in seconds) (OPTIONAL) */ 383 std::chrono::seconds _incDelay; 384 385 /* Zone's decrease interval(in seconds) (OPTIONAL) */ 386 std::chrono::seconds _decInterval; 387 388 /* The floor target to not go below */ 389 uint64_t _floor; 390 391 /* Target for this zone */ 392 uint64_t _target; 393 394 /* Zone increase delta */ 395 uint64_t _incDelta; 396 397 /* Zone decrease delta */ 398 uint64_t _decDelta; 399 400 /* The ceiling target to not go above */ 401 uint64_t _ceiling; 402 403 /* Requested target base */ 404 uint64_t _requestTargetBase; 405 406 /* Map of whether floor changes are allowed by a string identifier */ 407 std::map<std::string, bool> _floorChange; 408 409 /* Map of controlling decreases allowed by a string identifer */ 410 std::map<std::string, bool> _decAllowed; 411 412 /* Map of interfaces to persisted properties the zone hosts*/ 413 std::map<std::string, std::vector<std::string>> _propsPersisted; 414 415 /* Automatic fan control active state */ 416 bool _isActive; 417 418 /* The target increase timer object */ 419 Timer _incTimer; 420 421 /* The target decrease timer object */ 422 Timer _decTimer; 423 424 /* Map of active fan control allowed by a string identifier */ 425 std::map<std::string, bool> _active; 426 427 /* Interface to property mapping of their associated set property handler 428 * function */ 429 static const std::map< 430 std::string, 431 std::map<std::string, std::function<std::function<void( 432 DBusZone&, Zone&)>(const json&, bool)>>> 433 _intfPropHandlers; 434 435 /* List of fans included in this zone */ 436 std::vector<std::unique_ptr<Fan>> _fans; 437 438 /* List of configured interface set property functions */ 439 std::vector<std::function<void(DBusZone&, Zone&)>> _propInitFunctions; 440 441 /** 442 * @brief Parse and set the zone's poweron target value 443 * 444 * @param[in] jsonObj - JSON object for the zone 445 * 446 * Sets the poweron target value for the zone from the JSON configuration 447 * object 448 */ 449 void setPowerOnTarget(const json& jsonObj); 450 451 /** 452 * @brief Parse and set the interfaces served by the zone(OPTIONAL) 453 * 454 * @param[in] jsonObj - JSON object for the zone 455 * 456 * Constructs any zone interface handler functions for interfaces that the 457 * zone serves which contains the interface's property's value and 458 * persistency state (OPTIONAL). A property's "persist" state is defaulted 459 * to not be persisted when not given. 460 */ 461 void setInterfaces(const json& jsonObj); 462 463 /** 464 * @brief Get the request target base if defined, otherwise the the current 465 * target is returned 466 * 467 * @return - The request target base or current target 468 */ 469 inline auto getRequestTargetBase() const 470 { 471 return (_requestTargetBase != 0) ? _requestTargetBase : _target; 472 }; 473 }; 474 475 /** 476 * Properties of interfaces supported by the zone configuration 477 */ 478 namespace zone::property 479 { 480 481 /** 482 * @brief "Supported" property on the "xyz.openbmc_project.Control.ThermalMode" 483 * interface parser. Also creates the handler function for the Zone dbus object 484 * to initialize the property according to what's parsed from the configuration. 485 * 486 * @param[in] jsonObj - JSON object for the "Supported" property 487 * @param[in] persist - Whether to persist the value or not 488 * 489 * @return Zone dbus object's set property function for the "Supported" property 490 */ 491 std::function<void(DBusZone&, Zone&)> supported(const json& jsonObj, 492 bool persist); 493 494 /** 495 * @brief "Current" property on the "xyz.openbmc_project.Control.ThermalMode" 496 * interface parser. Also creates the handler function for the Zone dbus object 497 * to initialize the property according to what's parsed from the configuration. 498 * 499 * @param[in] jsonObj - JSON object for the "Current" property 500 * @param[in] persist - Whether to persist the value or not 501 * 502 * @return Zone dbus object's set property function for the "Current" property 503 */ 504 std::function<void(DBusZone&, Zone&)> current(const json& jsonObj, 505 bool persist); 506 507 } // namespace zone::property 508 509 } // namespace phosphor::fan::control::json 510