xref: /openbmc/openpower-occ-control/powermode.hpp (revision 7bd6d148e4f204266fe8ffd3df8aa93cf0284cd0)
1 #pragma once
2 
3 #include "config.h"
4 
5 #ifdef POWER10
6 #include "occ_command.hpp"
7 
8 #include <cereal/archives/json.hpp>
9 #include <cereal/cereal.hpp>
10 #include <cereal/types/string.hpp>
11 #include <cereal/types/tuple.hpp>
12 #include <cereal/types/vector.hpp>
13 #include <sdbusplus/bus.hpp>
14 #include <sdbusplus/bus/match.hpp>
15 #include <xyz/openbmc_project/Control/Power/IdlePowerSaver/server.hpp>
16 #include <xyz/openbmc_project/Control/Power/Mode/server.hpp>
17 
18 #include <filesystem>
19 
20 namespace open_power
21 {
22 namespace occ
23 {
24 
25 class Manager;
26 
27 namespace powermode
28 {
29 namespace Base = sdbusplus::xyz::openbmc_project::Control::Power::server;
30 using ModeInterface = sdbusplus::server::object_t<Base::Mode>;
31 using IpsInterface = sdbusplus::server::object_t<Base::IdlePowerSaver>;
32 using namespace std::literals::string_literals;
33 
34 constexpr auto PMODE_PATH = "/xyz/openbmc_project/control/host0/power_mode";
35 constexpr auto PMODE_INTERFACE = "xyz.openbmc_project.Control.Power.Mode";
36 constexpr auto POWER_MODE_PROP = "PowerMode";
37 constexpr auto POWER_SAFE_MODE_PROP = "SafeMode";
38 
39 constexpr auto PIPS_PATH = "/xyz/openbmc_project/control/host0/power_ips";
40 constexpr auto PIPS_INTERFACE =
41     "xyz.openbmc_project.Control.Power.IdlePowerSaver";
42 constexpr auto IPS_ACTIVE_PROP = "Active";
43 constexpr auto IPS_ENABLED_PROP = "Enabled";
44 constexpr auto IPS_ENTER_UTIL = "EnterUtilizationPercent";
45 constexpr auto IPS_ENTER_TIME = "EnterDwellTime";
46 constexpr auto IPS_EXIT_UTIL = "ExitUtilizationPercent";
47 constexpr auto IPS_EXIT_TIME = "ExitDwellTime";
48 
49 const auto PMODE_DEFAULT_INTERFACE =
50     "xyz.openbmc_project.Configuration.PowerModeProperties"s;
51 
52 /** @brief Query the current Hypervisor target
53  * @return true if the current Hypervisor target is PowerVM
54  */
55 bool isPowerVM();
56 
57 /** @brief Convert power mode string to OCC SysPwrMode value
58  *
59  * @param[in] i_modeString - power mode string
60  *
61  * @return  SysPwrMode or SysPwrMode::NO_CHANGE if not found
62  */
63 SysPwrMode convertStringToMode(const std::string& i_modeString);
64 
65 struct PowerModeData
66 {
67     bool modeInitialized = false;
68     SysPwrMode mode = SysPwrMode::NO_CHANGE;
69     uint16_t oemModeData = 0x0000;
70     bool ipsInitialized = false;
71     bool ipsEnabled = true;
72     uint8_t ipsEnterUtil = 0;
73     uint16_t ipsEnterTime = 0;
74     uint8_t ipsExitUtil = 0;
75     uint16_t ipsExitTime = 0;
76     bool modeLocked = false;
77 
78     /** @brief Function specifying data to archive for cereal.
79      */
80     template <class Archive>
81     void serialize(Archive& archive)
82     {
83         archive(modeInitialized, mode, oemModeData, ipsInitialized, ipsEnabled,
84                 ipsEnterUtil, ipsEnterTime, ipsExitUtil, ipsExitTime,
85                 modeLocked);
86     }
87 };
88 
89 /** @class OccPersistData
90  *  @brief Provides persistent container to store data for OCC
91  *
92  * Data is stored via cereal
93  */
94 class OccPersistData
95 {
96   public:
97     ~OccPersistData() = default;
98     OccPersistData(const OccPersistData&) = default;
99     OccPersistData& operator=(const OccPersistData&) = default;
100     OccPersistData(OccPersistData&&) = default;
101     OccPersistData& operator=(OccPersistData&&) = default;
102 
103     /** @brief Loads any saved power mode data */
104     OccPersistData()
105     {
106         load();
107     }
108 
109     /** @brief Save Power Mode data to persistent file
110      *
111      *  @param[in] newMode - desired System Power Mode
112      *  @param[in] oemModeData - data required by some OEM Power Modes
113      */
114     void updateMode(const SysPwrMode newMode, const uint16_t oemModeData)
115     {
116         modeData.mode = newMode;
117         modeData.oemModeData = oemModeData;
118         modeData.modeInitialized = true;
119         save();
120     }
121 
122     /** @brief Save Power Mode Lock value to persistent file
123      *
124      *  @param[in] modeLock - desired System Power Mode Lock
125      */
126     void updateModeLock(const bool modeLock)
127     {
128         modeData.modeLocked = modeLock;
129         save();
130     }
131     /** @brief Write Idle Power Saver parameters to persistent file
132      *
133      *  @param[in] enabled - Idle Power Save status (true = enabled)
134      *  @param[in] enterUtil - IPS Enter Utilization (%)
135      *  @param[in] enterTime - IPS Enter Time (seconds)
136      *  @param[in] exitUtil - IPS Exit Utilization (%)
137      *  @param[in] exitTime - IPS Exit Time (seconds)
138      */
139     void updateIPS(const bool enabled, const uint8_t enterUtil,
140                    const uint16_t enterTime, const uint8_t exitUtil,
141                    const uint16_t exitTime)
142     {
143         modeData.ipsEnabled = enabled;
144         modeData.ipsEnterUtil = enterUtil;
145         modeData.ipsEnterTime = enterTime;
146         modeData.ipsExitUtil = exitUtil;
147         modeData.ipsExitTime = exitTime;
148         modeData.ipsInitialized = true;
149         save();
150     }
151 
152     /** @brief Return the Power Mode and mode data
153      *
154      *  @param[out] mode - current system power mode
155      *  @param[out] oemModeData - frequency data for some OEM mode
156      *
157      *  @returns true if mode was available
158      */
159     bool getMode(SysPwrMode& mode, uint16_t& oemModeData) const
160     {
161         if (!modeData.modeInitialized)
162         {
163             return false;
164         }
165 
166         mode = modeData.mode;
167         oemModeData = modeData.oemModeData;
168         return true;
169     }
170 
171     /** @brief Get the Idle Power Saver properties from DBus
172      *
173      *  @param[out] enabled - Idle Power Save status (true = enabled)
174      *  @param[out] enterUtil - IPS Enter Utilization (%)
175      *  @param[out] enterTime - IPS Enter Time (seconds)
176      *  @param[out] exitUtil - IPS Exit Utilization (%)
177      *  @param[out] exitTime - IPS Exit Time (seconds)
178      *
179      * @return true if parameters were read successfully
180      */
181     bool getIPS(bool& enabled, uint8_t& enterUtil, uint16_t& enterTime,
182                 uint8_t& exitUtil, uint16_t& exitTime)
183     {
184         if (!modeData.ipsInitialized)
185         {
186             return false;
187         }
188 
189         enabled = modeData.ipsEnabled;
190         enterUtil = modeData.ipsEnterUtil;
191         enterTime = modeData.ipsEnterTime;
192         exitUtil = modeData.ipsExitUtil;
193         exitTime = modeData.ipsExitTime;
194         return true;
195     }
196 
197     /** @brief Return persisted mode lock */
198     bool getModeLock()
199     {
200         return modeData.modeLocked;
201     }
202 
203     /** @brief Return true if the power mode is available */
204     bool modeAvailable()
205     {
206         return (modeData.modeInitialized);
207     }
208 
209     /** @brief Return true if the IPS data is available */
210     bool ipsAvailable()
211     {
212         return (modeData.ipsInitialized);
213     }
214 
215     /** @brief Saves the Power Mode data in the filesystem using cereal. */
216     void save();
217 
218     /** @brief Trace the Power Mode and IPS parameters. */
219     void print();
220 
221   private:
222     /** @brief Power Mode data filename to store persistent data */
223     static constexpr auto powerModeFilename = "powerModeData";
224 
225     /** @brief Power Mode data object to be persisted */
226     PowerModeData modeData;
227 
228     /** @brief Loads the OEM mode data in the filesystem using cereal. */
229     void load();
230 };
231 
232 /** @class PowerMode
233  *  @brief Monitors for changes to the power mode and notifies occ
234  *
235  *  The customer power mode is provided to the OCC by host TMGT when the occ
236  *  first goes active or is reset.  This code is responsible for sending
237  *  the power mode to the OCC if the mode is changed while the occ is active.
238  */
239 
240 class PowerMode : public ModeInterface, public IpsInterface
241 {
242   public:
243     /** @brief PowerMode object to inform occ of changes to mode
244      *
245      * This object will monitor for changes to the power mode setting.
246      * If a change is detected, and the occ is active, then this object will
247      * notify the OCC of the change.
248      *
249      * @param[in] managerRef - manager object reference
250      * @param[in] modePath - Power Mode dbus path
251      * @param[in] ipsPath - Idle Power Saver dbus path
252      */
253     explicit PowerMode(const Manager& managerRef, const char* modePath,
254                        const char* ipsPath
255 #ifdef POWER10
256                        ,
257                        EventPtr& event
258 #endif
259                        ) :
260         ModeInterface(utils::getBus(), modePath,
261                       ModeInterface::action::emit_no_signals),
262         IpsInterface(utils::getBus(), ipsPath,
263                      IpsInterface::action::emit_no_signals),
264         manager(managerRef),
265         pmodeMatch(utils::getBus(),
266                    sdbusplus::bus::match::rules::propertiesChanged(
267                        PMODE_PATH, PMODE_INTERFACE),
268                    [this](auto& msg) { this->modeChanged(msg); }),
269         ipsMatch(utils::getBus(),
270                  sdbusplus::bus::match::rules::propertiesChanged(
271                      PIPS_PATH, PIPS_INTERFACE),
272                  [this](auto& msg) { this->ipsChanged(msg); }),
273         defaultsUpdateMatch(
274             utils::getBus(),
275             sdbusplus::bus::match::rules::propertiesChangedNamespace(
276                 "/xyz/openbmc_project/inventory", PMODE_DEFAULT_INTERFACE),
277             [this](auto& msg) { this->defaultsReady(msg); }),
278         masterOccSet(false), masterActive(false)
279 #ifdef POWER10
280         ,
281         event(event)
282 #endif
283     {
284         // restore Power Mode to DBus
285         SysPwrMode currentMode;
286         uint16_t oemModeData = 0;
287         if (getMode(currentMode, oemModeData))
288         {
289             updateDbusMode(currentMode);
290         }
291         // restore Idle Power Saver parameters to DBus
292         uint8_t enterUtil, exitUtil;
293         uint16_t enterTime, exitTime;
294         bool ipsEnabled;
295         if (getIPSParms(ipsEnabled, enterUtil, enterTime, exitUtil, exitTime))
296         {
297             updateDbusIPS(ipsEnabled, enterUtil, enterTime, exitUtil, exitTime);
298         }
299     };
300 
301     /** @brief Initialize the persistent data with default values
302      *
303      * @return true if initialization completed
304      */
305     bool initPersistentData();
306 
307     /** @brief Set the power mode lock (dbus method)
308      *
309      * @return true if successful
310      */
311     bool powerModeLock();
312 
313     /** @brief Get the power mode lock status (dbus method)
314      *
315      * @return true if locked
316      */
317     bool powerModeLockStatus();
318 
319     /** @brief Set the current power mode property
320      *
321      * @param[in] newMode     - desired system power mode
322      * @param[in] oemModeData - data required by some OEM Power Modes
323      *
324      * @return true if mode accepted
325      */
326     bool setMode(const SysPwrMode newMode, const uint16_t oemModeData);
327 
328     /** @brief Send mode change command to the master OCC
329      *  @return SUCCESS on success
330      */
331     CmdStatus sendModeChange();
332 
333     /** @brief Send Idle Power Saver config data to the master OCC
334      *  @return SUCCESS on success
335      */
336     CmdStatus sendIpsData();
337 
338     /** @brief Set the master OCC path
339      *
340      * @param[in]  occPath - hwmon path for master OCC
341      */
342     void setMasterOcc(const std::string& occPath);
343 
344     /** @brief Notify object of master OCC state.  If not acitve, no
345      * commands will be sent to the master OCC
346      *
347      * @param[in]  isActive - true when master OCC is active
348      */
349     void setMasterActive(const bool isActive = true)
350     {
351         masterActive = isActive;
352     };
353 
354 #ifdef POWER10
355     /** @brief Starts to monitor for IPS active state change conditions
356      *
357      *  @param[in] poll - Indicates whether or not the IPS state file should
358      *                    actually be read for changes.
359      */
360     void addIpsWatch(bool poll = true);
361 
362     /** @brief Removes IPS active watch */
363     void removeIpsWatch();
364 #endif
365 
366     /** @brief Set dbus property to SAFE Mode(true) or clear SAFE Mode(false)*/
367     void updateDbusSafeMode(const bool safeMode);
368 
369     /** @brief override the set/get MODE function
370      *
371      *  @param[in] value - Intended value
372      *
373      *  @return          - the value or Updated value of the property
374      */
375     Base::Mode::PowerMode powerMode(Base::Mode::PowerMode value) override;
376 
377   private:
378     /** @brief OCC manager object */
379     const Manager& manager;
380 
381     /** @brief Pass-through occ path on the bus */
382     std::string path;
383 
384     /** @brief OCC instance number */
385     int occInstance;
386 
387     /** @brief Object to send commands to the OCC */
388     std::unique_ptr<open_power::occ::OccCommand> occCmd;
389 
390     /** @brief Used to subscribe to dbus pmode property changes **/
391     sdbusplus::bus::match_t pmodeMatch;
392 
393     /** @brief Used to subscribe to dbus IPS property changes **/
394     sdbusplus::bus::match_t ipsMatch;
395 
396     /** @brief Used to subscribe to dbus defaults property changes **/
397     sdbusplus::bus::match_t defaultsUpdateMatch;
398 
399     OccPersistData persistedData;
400 
401     /** @brief True when the master OCC has been established */
402     bool masterOccSet;
403 
404     /** @brief True when the master OCC is active */
405     bool masterActive;
406 
407 #ifdef POWER10
408     /** @brief IPS status data filename to read */
409     const fs::path ipsStatusFile = std::filesystem::path{OCC_HWMON_PATH} /
410                                    std::filesystem::path{OCC_MASTER_NAME} /
411                                    "occ_ips_status";
412 
413     /** @brief Current state of error watching */
414     bool watching = false;
415 
416     /** @brief register for the callback from the POLL IPS changed event */
417     void registerIpsStatusCallBack();
418 #endif
419 
420     /** @brief Callback for pmode setting changes
421      *
422      * Process change and inform OCC
423      *
424      * @param[in]  msg       - Data associated with pmode change signal
425      *
426      */
427     void modeChanged(sdbusplus::message_t& msg);
428 
429     /** @brief Get the current power mode property
430      *
431      * @param[out] currentMode - current system power mode
432      * @param[out] oemModeData - frequency data for some OEM mode
433      *
434      * @return true if data read successfully
435      */
436     bool getMode(SysPwrMode& currentMode, uint16_t& oemModeData);
437 
438     /** @brief Update the power mode property on DBus
439      *
440      * @param[in]  newMode - desired power mode
441      *
442      * @return true on success
443      */
444     bool updateDbusMode(const SysPwrMode newMode);
445 
446     /** @brief Callback for IPS setting changes
447      *
448      * Process change and inform OCC
449      *
450      * @param[in]  msg - Data associated with IPS change signal
451      *
452      */
453     void ipsChanged(sdbusplus::message_t& msg);
454 
455     /** @brief Get the Idle Power Saver properties
456      *
457      *  @param[out] enabled - Idle Power Save status (true = enabled)
458      *  @param[out] enterUtil - IPS Enter Utilization (%)
459      *  @param[out] enterTime - IPS Enter Time (seconds)
460      *  @param[out] exitUtil - IPS Exit Utilization (%)
461      *  @param[out] exitTime - IPS Exit Time (seconds)
462      *
463      * @return true if data read successfully
464      */
465     bool getIPSParms(bool& enabled, uint8_t& enterUtil, uint16_t& enterTime,
466                      uint8_t& exitUtil, uint16_t& exitTime);
467 
468     /** Update the Idle Power Saver data on DBus
469      *
470      *  @param[in] enabled - Idle Power Save status (true = enabled)
471      *  @param[in] enterUtil - IPS Enter Utilization (%)
472      *  @param[in] enterTime - IPS Enter Time (seconds)
473      *  @param[in] exitUtil - IPS Exit Utilization (%)
474      *  @param[in] exitTime - IPS Exit Time (seconds)
475      *
476      *  @return true if parameters were set successfully
477      */
478     bool updateDbusIPS(const bool enabled, const uint8_t enterUtil,
479                        const uint16_t enterTime, const uint8_t exitUtil,
480                        const uint16_t exitTime);
481 
482     /** @brief Callback for entity manager default changes
483      *
484      * Called when PowerModeProperties defaults are available
485      */
486     void defaultsReady(sdbusplus::message_t& msg);
487 
488     /** @brief Get the default power mode property for this system type
489      *
490      * @param[out] defaultMode - default system power mode
491      *
492      * @return true if data read successfully
493      */
494     bool getDefaultMode(SysPwrMode& defaultMode);
495 
496     /** @brief Get the default Idle Power Saver properties for this system type
497      *
498      *  @param[out] enabled - Idle Power Save status (true = enabled)
499      *  @param[out] enterUtil - IPS Enter Utilization (%)
500      *  @param[out] enterTime - IPS Enter Time (seconds)
501      *  @param[out] exitUtil - IPS Exit Utilization (%)
502      *  @param[out] exitTime - IPS Exit Time (seconds)
503      *
504      *  @return true if parameters were read successfully
505      */
506     bool getDefaultIPSParms(bool& enabled, uint8_t& enterUtil,
507                             uint16_t& enterTime, uint8_t& exitUtil,
508                             uint16_t& exitTime);
509 
510     /** @brief Read the default Idle Power Saver parameters and save them to the
511      * DBUS so they will get used
512      *
513      * @return true if restore was successful
514      */
515     bool useDefaultIPSParms();
516 
517 #ifdef POWER10
518     /** @brief callback for the POLL IPS changed event
519      *
520      *  @param[in] es       - Populated event source
521      *  @param[in] fd       - Associated File descriptor
522      *  @param[in] revents  - Type of event
523      *  @param[in] userData - User data that was passed during registration
524      */
525     static int ipsStatusCallBack(sd_event_source* es, int fd, uint32_t revents,
526                                  void* userData);
527 
528     /** @brief Opens the IPS file and populates fd */
529     bool openIpsFile();
530 
531     /** @brief sd_event wrapped in unique_ptr */
532     EventPtr& event;
533 
534     /** @brief event source wrapped in unique_ptr */
535     EventSourcePtr eventSource;
536 
537     /** @brief When the ips status event is received, analyzes it */
538     virtual void analyzeIpsEvent();
539 
540   protected:
541     /** @brief File descriptor to watch for errors */
542     int fd = -1;
543 #endif
544 };
545 
546 } // namespace powermode
547 
548 } // namespace occ
549 
550 } // namespace open_power
551 #endif
552