powermode.hpp

#pragma once

#include "config.h"

#ifdef POWER10
#include "occ_command.hpp"

#include <cereal/archives/json.hpp>
//#include <cereal/archives/binary.hpp>
#include <cereal/cereal.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/tuple.hpp>
#include <cereal/types/vector.hpp>
#include <sdbusplus/bus.hpp>
#include <sdbusplus/bus/match.hpp>
#include <xyz/openbmc_project/Control/Power/IdlePowerSaver/server.hpp>
#include <xyz/openbmc_project/Control/Power/Mode/server.hpp>

#include <filesystem>

namespace open_power
{
namespace occ
{

class Manager;

namespace powermode
{
namespace Base = sdbusplus::xyz::openbmc_project::Control::Power::server;
using ModeInterface = sdbusplus::server::object::object<Base::Mode>;
using IpsInterface = sdbusplus::server::object::object<Base::IdlePowerSaver>;
using namespace std::literals::string_literals;

constexpr auto PMODE_PATH = "/xyz/openbmc_project/control/host0/power_mode";
constexpr auto PMODE_INTERFACE = "xyz.openbmc_project.Control.Power.Mode";
constexpr auto POWER_MODE_PROP = "PowerMode";

constexpr auto PIPS_PATH = "/xyz/openbmc_project/control/host0/power_ips";
constexpr auto PIPS_INTERFACE =
    "xyz.openbmc_project.Control.Power.IdlePowerSaver";
constexpr auto IPS_ENABLED_PROP = "Enabled";
constexpr auto IPS_ENTER_UTIL = "EnterUtilizationPercent";
constexpr auto IPS_ENTER_TIME = "EnterDwellTime";
constexpr auto IPS_EXIT_UTIL = "ExitUtilizationPercent";
constexpr auto IPS_EXIT_TIME = "ExitDwellTime";

const auto PMODE_DEFAULT_INTERFACE =
    "xyz.openbmc_project.Configuration.PowerModeProperties"s;

/** @brief Query the current Hypervisor target
 * @return true if the current Hypervisor target is PowerVM
 */
bool isPowerVM();

/** @brief Convert power mode string to OCC SysPwrMode value
 *
 * @param[in] i_modeString - power mode string
 *
 * @return  SysPwrMode or SysPwrMode::NO_CHANGE if not found
 */
SysPwrMode convertStringToMode(const std::string& i_modeString);

struct PowerModeData
{
    bool modeInitialized = false;
    SysPwrMode mode = SysPwrMode::NO_CHANGE;
    uint16_t oemModeData = 0x0000;
    bool ipsInitialized = false;
    bool ipsEnabled = true;
    uint8_t ipsEnterUtil = 0;
    uint16_t ipsEnterTime = 0;
    uint8_t ipsExitUtil = 0;
    uint16_t ipsExitTime = 0;

    /** @brief Function specifying data to archive for cereal.
     */
    template <class Archive>
    void serialize(Archive& archive)
    {
        archive(modeInitialized, mode, oemModeData, ipsInitialized, ipsEnabled,
                ipsEnterUtil, ipsEnterTime, ipsExitUtil, ipsExitTime);
    }
};

/** @class OccPersistData
 *  @brief Provides persistent container to store data for OCC
 *
 * Data is stored via cereal
 */
class OccPersistData
{
  public:
    ~OccPersistData() = default;
    OccPersistData(const OccPersistData&) = default;
    OccPersistData& operator=(const OccPersistData&) = default;
    OccPersistData(OccPersistData&&) = default;
    OccPersistData& operator=(OccPersistData&&) = default;

    /** @brief Loads any saved power mode data */
    OccPersistData()
    {
        load();
    }

    /** @brief Save Power Mode data to persistent file
     *
     *  @param[in] newMode - desired System Power Mode
     *  @param[in] oemModeData - data required by some OEM Power Modes
     */
    void updateMode(const SysPwrMode newMode, const uint16_t oemModeData)
    {
        modeData.mode = newMode;
        modeData.oemModeData = oemModeData;
        modeData.modeInitialized = true;
        save();
    }

    /** @brief Write Idle Power Saver parameters to persistent file
     *
     *  @param[in] enabled - Idle Power Save status (true = enabled)
     *  @param[in] enterUtil - IPS Enter Utilization (%)
     *  @param[in] enterTime - IPS Enter Time (seconds)
     *  @param[in] exitUtil - IPS Exit Utilization (%)
     *  @param[in] exitTime - IPS Exit Time (seconds)
     */
    void updateIPS(const bool enabled, const uint8_t enterUtil,
                   const uint16_t enterTime, const uint8_t exitUtil,
                   const uint16_t exitTime)
    {
        modeData.ipsEnabled = enabled;
        modeData.ipsEnterUtil = enterUtil;
        modeData.ipsEnterTime = enterTime;
        modeData.ipsExitUtil = exitUtil;
        modeData.ipsExitTime = exitTime;
        modeData.ipsInitialized = true;
        save();
    }

    /** @brief Return the Power Mode and mode data
     *
     *  @param[out] mode - current system power mode
     *  @param[out] oemModeData - frequency data for some OEM mode
     *
     *  @returns true if mode was available
     */
    bool getMode(SysPwrMode& mode, uint16_t& oemModeData) const
    {
        if (!modeData.modeInitialized)
        {
            return false;
        }

        mode = modeData.mode;
        oemModeData = modeData.oemModeData;
        return true;
    }

    /** @brief Get the Idle Power Saver properties from DBus
     *
     *  @param[out] enabled - Idle Power Save status (true = enabled)
     *  @param[out] enterUtil - IPS Enter Utilization (%)
     *  @param[out] enterTime - IPS Enter Time (seconds)
     *  @param[out] exitUtil - IPS Exit Utilization (%)
     *  @param[out] exitTime - IPS Exit Time (seconds)
     *
     * @return true if parameters were read successfully
     */
    bool getIPS(bool& enabled, uint8_t& enterUtil, uint16_t& enterTime,
                uint8_t& exitUtil, uint16_t& exitTime)
    {
        if (!modeData.ipsInitialized)
        {
            return false;
        }

        enabled = modeData.ipsEnabled;
        enterUtil = modeData.ipsEnterUtil;
        enterTime = modeData.ipsEnterTime;
        exitUtil = modeData.ipsExitUtil;
        exitTime = modeData.ipsExitTime;
        return true;
    }

    /** @brief Return true if the power mode is available */
    bool modeAvailable()
    {
        return (modeData.modeInitialized);
    }

    /** @brief Return true if the power mode is available */
    bool ipsAvailable()
    {
        return (modeData.ipsInitialized);
    }

    /** @brief Saves the Power Mode data in the filesystem using cereal. */
    void save();

    /** @brief Trace the Power Mode and IPS parameters. */
    void print();

  private:
    /** @brief Power Mode data filename to store persistent data */
    static constexpr auto powerModeFilename = "powerModeData";

    /** @brief Power Mode data object to be persisted */
    PowerModeData modeData;

    /** @brief Loads the OEM mode data in the filesystem using cereal. */
    void load();
};

/** @class PowerMode
 *  @brief Monitors for changes to the power mode and notifies occ
 *
 *  The customer power mode is provided to the OCC by host TMGT when the occ
 *  first goes active or is reset.  This code is responsible for sending
 *  the power mode to the OCC if the mode is changed while the occ is active.
 */

class PowerMode : public ModeInterface, public IpsInterface
{
  public:
    /** @brief PowerMode object to inform occ of changes to mode
     *
     * This object will monitor for changes to the power mode setting.
     * If a change is detected, and the occ is active, then this object will
     * notify the OCC of the change.
     *
     * @param[in] managerRef - manager object reference
     * @param[in] modePath - Power Mode dbus path
     * @param[in] ipsPath - Idle Power Saver dbus path
     */
    explicit PowerMode(const Manager& managerRef, const char* modePath,
                       const char* ipsPath) :
        ModeInterface(utils::getBus(), modePath, false),
        IpsInterface(utils::getBus(), ipsPath, false), manager(managerRef),
        pmodeMatch(utils::getBus(),
                   sdbusplus::bus::match::rules::propertiesChanged(
                       PMODE_PATH, PMODE_INTERFACE),
                   [this](auto& msg) { this->modeChanged(msg); }),
        ipsMatch(utils::getBus(),
                 sdbusplus::bus::match::rules::propertiesChanged(
                     PIPS_PATH, PIPS_INTERFACE),
                 [this](auto& msg) { this->ipsChanged(msg); }),
        defaultsUpdateMatch(
            utils::getBus(),
            sdbusplus::bus::match::rules::propertiesChangedNamespace(
                "/xyz/openbmc_project/inventory", PMODE_DEFAULT_INTERFACE),
            [this](auto& msg) { this->defaultsReady(msg); }),
        masterOccSet(false), masterActive(false)
    {
        // restore Power Mode to DBus
        SysPwrMode currentMode;
        uint16_t oemModeData = 0;
        if (getMode(currentMode, oemModeData))
        {
            updateDbusMode(currentMode);
        }
        // restore Idle Power Saver parameters to DBus
        uint8_t enterUtil, exitUtil;
        uint16_t enterTime, exitTime;
        bool ipsEnabled;
        if (getIPSParms(ipsEnabled, enterUtil, enterTime, exitUtil, exitTime))
        {
            updateDbusIPS(ipsEnabled, enterUtil, enterTime, exitUtil, exitTime);
        }
    };

    /** @brief Initialize the persistent data with default values
     *
     * @return true if initialization completed
     */
    bool initPersistentData();

    /** @brief Set the current power mode property
     *
     * @param[in] newMode     - desired system power mode
     * @param[in] oemModeData - data required by some OEM Power Modes
     *
     * @return true if mode accepted
     */
    bool setMode(const SysPwrMode newMode, const uint16_t oemModeData);

    /** @brief Send mode change command to the master OCC
     *  @return SUCCESS on success
     */
    CmdStatus sendModeChange();

    /** @brief Send Idle Power Saver config data to the master OCC
     *  @return SUCCESS on success
     */
    CmdStatus sendIpsData();

    /** @brief Set the master OCC path
     *
     * @param[in]  occPath - hwmon path for master OCC
     */
    void setMasterOcc(const std::string& occPath);

    /** @brief Notify object of master OCC state.  If not acitve, no
     * commands will be sent to the master OCC
     *
     * @param[in]  isActive - true when master OCC is active
     */
    void setMasterActive(const bool isActive = true)
    {
        masterActive = isActive;
    };

  private:
    /** @brief OCC manager object */
    const Manager& manager;

    /** @brief Pass-through occ path on the bus */
    std::string path;

    /** @brief OCC instance number */
    int occInstance;

    /** @brief Object to send commands to the OCC */
    std::unique_ptr<open_power::occ::OccCommand> occCmd;

    /** @brief Used to subscribe to dbus pmode property changes **/
    sdbusplus::bus::match_t pmodeMatch;

    /** @brief Used to subscribe to dbus IPS property changes **/
    sdbusplus::bus::match_t ipsMatch;

    /** @brief Used to subscribe to dbus defaults property changes **/
    sdbusplus::bus::match_t defaultsUpdateMatch;

    OccPersistData persistedData;

    /** @brief True when the master OCC has been established */
    bool masterOccSet;

    /** @brief True when the master OCC is active */
    bool masterActive;

    /** @brief Callback for pmode setting changes
     *
     * Process change and inform OCC
     *
     * @param[in]  msg       - Data associated with pmode change signal
     *
     */
    void modeChanged(sdbusplus::message::message& msg);

    /** @brief Get the current power mode property
     *
     * @param[out] currentMode - current system power mode
     * @param[out] oemModeData - frequency data for some OEM mode
     *
     * @return true if data read successfully
     */
    bool getMode(SysPwrMode& currentMode, uint16_t& oemModeData);

    /** @brief Update the power mode property on DBus
     *
     * @param[in]  newMode - desired power mode
     *
     * @return true on success
     */
    bool updateDbusMode(const SysPwrMode newMode);

    /** @brief Callback for IPS setting changes
     *
     * Process change and inform OCC
     *
     * @param[in]  msg - Data associated with IPS change signal
     *
     */
    void ipsChanged(sdbusplus::message::message& msg);

    /** @brief Get the Idle Power Saver properties
     *
     *  @param[out] enabled - Idle Power Save status (true = enabled)
     *  @param[out] enterUtil - IPS Enter Utilization (%)
     *  @param[out] enterTime - IPS Enter Time (seconds)
     *  @param[out] exitUtil - IPS Exit Utilization (%)
     *  @param[out] exitTime - IPS Exit Time (seconds)
     *
     * @return true if data read successfully
     */
    bool getIPSParms(bool& enabled, uint8_t& enterUtil, uint16_t& enterTime,
                     uint8_t& exitUtil, uint16_t& exitTime);

    /** Update the Idle Power Saver data on DBus
     *
     *  @param[in] enabled - Idle Power Save status (true = enabled)
     *  @param[in] enterUtil - IPS Enter Utilization (%)
     *  @param[in] enterTime - IPS Enter Time (seconds)
     *  @param[in] exitUtil - IPS Exit Utilization (%)
     *  @param[in] exitTime - IPS Exit Time (seconds)
     *
     *  @return true if parameters were set successfully
     */
    bool updateDbusIPS(const bool enabled, const uint8_t enterUtil,
                       const uint16_t enterTime, const uint8_t exitUtil,
                       const uint16_t exitTime);

    /** @brief Callback for entity manager default changes
     *
     * Called when PowerModeProperties defaults are available
     */
    void defaultsReady(sdbusplus::message::message& msg);

    /** @brief Get the default power mode property for this system type
     *
     * @param[out] defaultMode - default system power mode
     *
     * @return true if data read successfully
     */
    bool getDefaultMode(SysPwrMode& defaultMode);

    /** @brief Get the default Idle Power Saver properties for this system type
     *
     *  @param[out] enabled - Idle Power Save status (true = enabled)
     *  @param[out] enterUtil - IPS Enter Utilization (%)
     *  @param[out] enterTime - IPS Enter Time (seconds)
     *  @param[out] exitUtil - IPS Exit Utilization (%)
     *  @param[out] exitTime - IPS Exit Time (seconds)
     *
     *  @return true if parameters were read successfully
     */
    bool getDefaultIPSParms(bool& enabled, uint8_t& enterUtil,
                            uint16_t& enterTime, uint8_t& exitUtil,
                            uint16_t& exitTime);
};

} // namespace powermode

} // namespace occ

} // namespace open_power
#endif