blob: 88422bf4016dde527469b4873df768a68305681f [file] [log] [blame]
#include "powermode.hpp"
#include <fcntl.h>
#include <sys/ioctl.h>
#include <format>
#ifdef POWERVM_CHECK
#include <com/ibm/Host/Target/server.hpp>
#endif
#include <org/open_power/OCC/Device/error.hpp>
#include <phosphor-logging/elog-errors.hpp>
#include <phosphor-logging/log.hpp>
#include <xyz/openbmc_project/Common/error.hpp>
#include <xyz/openbmc_project/Control/Power/Mode/server.hpp>
#include <cassert>
#include <fstream>
#include <regex>
namespace open_power
{
namespace occ
{
namespace powermode
{
using namespace phosphor::logging;
using namespace std::literals::string_literals;
using namespace sdbusplus::org::open_power::OCC::Device::Error;
using Mode = sdbusplus::xyz::openbmc_project::Control::Power::server::Mode;
using NotAllowed = sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed;
using Reason = xyz::openbmc_project::Common::NotAllowed::REASON;
// Set the Master OCC
void PowerMode::setMasterOcc(const std::string& masterOccPath)
{
if (masterOccSet)
{
if (masterOccPath != path)
{
log<level::ERR>(
std::format(
"PowerMode::setMasterOcc: Master changed (was OCC{}, {})",
occInstance, masterOccPath)
.c_str());
if (occCmd)
{
occCmd.reset();
}
}
}
path = masterOccPath;
occInstance = path.back() - '0';
log<level::DEBUG>(std::format("PowerMode::setMasterOcc(OCC{}, {})",
occInstance, path.c_str())
.c_str());
if (!occCmd)
{
occCmd = std::make_unique<open_power::occ::OccCommand>(occInstance,
path.c_str());
}
masterOccSet = true;
};
// Called when DBus power mode gets changed
void PowerMode::modeChanged(sdbusplus::message_t& msg)
{
std::map<std::string, std::variant<std::string>> properties{};
std::string interface;
std::string propVal;
msg.read(interface, properties);
const auto modeEntry = properties.find(POWER_MODE_PROP);
if (modeEntry != properties.end())
{
auto modeEntryValue = modeEntry->second;
propVal = std::get<std::string>(modeEntryValue);
SysPwrMode newMode = convertStringToMode(propVal);
// If mode set was requested via direct dbus property change then we
// need to see if mode set is locked and ignore the request. We should
// not get to this path since the property change method should also be
// checking the mode lock status.
if (persistedData.getModeLock())
{
// Fix up the mode property since we are going to ignore this
// set mode request.
log<level::ERR>(
"PowerMode::modeChanged: mode property changed while locked");
SysPwrMode currentMode;
uint16_t oemModeData;
getMode(currentMode, oemModeData);
updateDbusMode(currentMode);
return;
}
if (newMode != SysPwrMode::NO_CHANGE)
{
// Update persisted data with new mode
persistedData.updateMode(newMode, 0);
log<level::INFO>(
std::format("DBus Power Mode Changed: {}", propVal).c_str());
// Send mode change to OCC
sendModeChange();
}
}
}
// Set the state of power mode lock. Writing persistent data via dbus method.
bool PowerMode::powerModeLock()
{
log<level::INFO>("PowerMode::powerModeLock: locking mode change");
persistedData.updateModeLock(true); // write persistent data
return true;
}
// Get the state of power mode. Reading persistent data via dbus method.
bool PowerMode::powerModeLockStatus()
{
bool status = persistedData.getModeLock(); // read persistent data
log<level::INFO>(std::format("PowerMode::powerModeLockStatus: {}",
status ? "locked" : "unlocked")
.c_str());
return status;
}
// Called from OCC PassThrough interface (via CE login / BMC command line)
bool PowerMode::setMode(const SysPwrMode newMode, const uint16_t oemModeData)
{
if (persistedData.getModeLock())
{
log<level::INFO>("PowerMode::setMode: mode change blocked");
return false;
}
if (updateDbusMode(newMode) == false)
{
// Unsupported mode
return false;
}
// Save mode
persistedData.updateMode(newMode, oemModeData);
// Send mode change to OCC
if (sendModeChange() != CmdStatus::SUCCESS)
{
// Mode change failed
return false;
}
return true;
}
// Convert PowerMode string to OCC SysPwrMode
// Returns NO_CHANGE if OEM or unsupported mode
SysPwrMode convertStringToMode(const std::string& i_modeString)
{
SysPwrMode pmode = SysPwrMode::NO_CHANGE;
Mode::PowerMode mode = Mode::convertPowerModeFromString(i_modeString);
if (mode == Mode::PowerMode::MaximumPerformance)
{
pmode = SysPwrMode::MAX_PERF;
}
else if (mode == Mode::PowerMode::PowerSaving)
{
pmode = SysPwrMode::POWER_SAVING;
}
else if (mode == Mode::PowerMode::Static)
{
pmode = SysPwrMode::STATIC;
}
else if (mode == Mode::PowerMode::EfficiencyFavorPower)
{
pmode = SysPwrMode::EFF_FAVOR_POWER;
}
else if (mode == Mode::PowerMode::EfficiencyFavorPerformance)
{
pmode = SysPwrMode::EFF_FAVOR_PERF;
}
else if (mode == Mode::PowerMode::BalancedPerformance)
{
pmode = SysPwrMode::BALANCED_PERF;
}
else
{
if (mode != Mode::PowerMode::OEM)
{
log<level::ERR>(
std::format(
"convertStringToMode: Invalid Power Mode specified: {}",
i_modeString)
.c_str());
}
}
return pmode;
}
// Check if Hypervisor target is PowerVM
bool isPowerVM()
{
bool powerVmTarget = true;
#ifdef POWERVM_CHECK
namespace Hyper = sdbusplus::com::ibm::Host::server;
constexpr auto HYPE_PATH = "/com/ibm/host0/hypervisor";
constexpr auto HYPE_INTERFACE = "com.ibm.Host.Target";
constexpr auto HYPE_PROP = "Target";
// This will throw exception on failure
auto& bus = utils::getBus();
auto service = utils::getService(HYPE_PATH, HYPE_INTERFACE);
auto method = bus.new_method_call(service.c_str(), HYPE_PATH,
"org.freedesktop.DBus.Properties", "Get");
method.append(HYPE_INTERFACE, HYPE_PROP);
auto reply = bus.call(method);
std::variant<std::string> hyperEntryValue;
reply.read(hyperEntryValue);
auto propVal = std::get<std::string>(hyperEntryValue);
if (Hyper::Target::convertHypervisorFromString(propVal) ==
Hyper::Target::Hypervisor::PowerVM)
{
powerVmTarget = true;
}
log<level::DEBUG>(
std::format("isPowerVM returning {}", powerVmTarget).c_str());
#endif
return powerVmTarget;
}
// Initialize persistent data and return true if successful
bool PowerMode::initPersistentData()
{
if (!persistedData.modeAvailable())
{
// Read the default mode
SysPwrMode currentMode;
if (!getDefaultMode(currentMode))
{
// Unable to read defaults
return false;
}
log<level::INFO>(
std::format("PowerMode::initPersistentData: Using default mode: {}",
currentMode)
.c_str());
// Save default mode as current mode
persistedData.updateMode(currentMode, 0);
// Write default mode to DBus
updateDbusMode(currentMode);
}
if (!persistedData.ipsAvailable())
{
// Read the default IPS parameters, write persistent file and update
// DBus
return useDefaultIPSParms();
}
return true;
}
// Get the requested power mode and return true if successful
bool PowerMode::getMode(SysPwrMode& currentMode, uint16_t& oemModeData)
{
currentMode = SysPwrMode::NO_CHANGE;
oemModeData = 0;
if (!persistedData.getMode(currentMode, oemModeData))
{
// Persistent data not initialized, read defaults and update DBus
if (!initPersistentData())
{
// Unable to read defaults from entity manager yet
return false;
}
return persistedData.getMode(currentMode, oemModeData);
}
return true;
}
// Set the power mode on DBus
bool PowerMode::updateDbusMode(const SysPwrMode newMode)
{
if (!VALID_POWER_MODE_SETTING(newMode) &&
!VALID_OEM_POWER_MODE_SETTING(newMode))
{
log<level::ERR>(
std::format(
"PowerMode::updateDbusMode - Requested power mode not supported: {}",
newMode)
.c_str());
return false;
}
// Convert mode for DBus
ModeInterface::PowerMode dBusMode;
switch (newMode)
{
case SysPwrMode::STATIC:
dBusMode = Mode::PowerMode::Static;
break;
case SysPwrMode::POWER_SAVING:
dBusMode = Mode::PowerMode::PowerSaving;
break;
case SysPwrMode::MAX_PERF:
dBusMode = Mode::PowerMode::MaximumPerformance;
break;
case SysPwrMode::EFF_FAVOR_POWER:
dBusMode = Mode::PowerMode::EfficiencyFavorPower;
break;
case SysPwrMode::EFF_FAVOR_PERF:
dBusMode = Mode::PowerMode::EfficiencyFavorPerformance;
break;
case SysPwrMode::BALANCED_PERF:
dBusMode = Mode::PowerMode::BalancedPerformance;
break;
default:
dBusMode = Mode::PowerMode::OEM;
}
// true = skip update signal
ModeInterface::setPropertyByName(POWER_MODE_PROP, dBusMode, true);
return true;
}
// Send mode change request to the master OCC
CmdStatus PowerMode::sendModeChange()
{
CmdStatus status;
if (!masterActive || !masterOccSet)
{
// Nothing to do
log<level::DEBUG>("PowerMode::sendModeChange: OCC master not active");
return CmdStatus::SUCCESS;
}
if (!isPowerVM())
{
// Mode change is only supported on PowerVM systems
log<level::DEBUG>(
"PowerMode::sendModeChange: MODE CHANGE does not get sent on non-PowerVM systems");
return CmdStatus::SUCCESS;
}
SysPwrMode newMode;
uint16_t oemModeData = 0;
getMode(newMode, oemModeData);
if (VALID_POWER_MODE_SETTING(newMode) ||
VALID_OEM_POWER_MODE_SETTING(newMode))
{
std::vector<std::uint8_t> cmd, rsp;
cmd.reserve(9);
cmd.push_back(uint8_t(CmdType::SET_MODE_AND_STATE));
cmd.push_back(0x00); // Data Length (2 bytes)
cmd.push_back(0x06);
cmd.push_back(0x30); // Data (Version)
cmd.push_back(uint8_t(OccState::NO_CHANGE));
cmd.push_back(uint8_t(newMode));
cmd.push_back(oemModeData >> 8); // Mode Data (Freq Point)
cmd.push_back(oemModeData & 0xFF); //
cmd.push_back(0x00); // reserved
log<level::INFO>(
std::format(
"PowerMode::sendModeChange: SET_MODE({},{}) command to OCC{} ({} bytes)",
newMode, oemModeData, occInstance, cmd.size())
.c_str());
status = occCmd->send(cmd, rsp);
if (status == CmdStatus::SUCCESS)
{
if (rsp.size() == 5)
{
if (RspStatus::SUCCESS != RspStatus(rsp[2]))
{
log<level::ERR>(
std::format(
"PowerMode::sendModeChange: SET MODE failed with status 0x{:02X}",
rsp[2])
.c_str());
dump_hex(rsp);
status = CmdStatus::FAILURE;
}
}
else
{
log<level::ERR>(
"PowerMode::sendModeChange: INVALID SET MODE response");
dump_hex(rsp);
status = CmdStatus::FAILURE;
}
}
else
{
log<level::ERR>(
std::format(
"PowerMode::sendModeChange: SET_MODE FAILED with status={}",
status)
.c_str());
}
}
else
{
log<level::ERR>(
std::format(
"PowerMode::sendModeChange: Unable to set power mode to {}",
newMode)
.c_str());
status = CmdStatus::FAILURE;
}
return status;
}
void PowerMode::ipsChanged(sdbusplus::message_t& msg)
{
bool parmsChanged = false;
std::string interface;
std::map<std::string, std::variant<bool, uint8_t, uint64_t>>
ipsProperties{};
msg.read(interface, ipsProperties);
// Read persisted values
bool ipsEnabled;
uint8_t enterUtil, exitUtil;
uint16_t enterTime, exitTime;
getIPSParms(ipsEnabled, enterUtil, enterTime, exitUtil, exitTime);
// Check for any changed data
auto ipsEntry = ipsProperties.find(IPS_ENABLED_PROP);
if (ipsEntry != ipsProperties.end())
{
ipsEnabled = std::get<bool>(ipsEntry->second);
log<level::INFO>(
std::format("Idle Power Saver change: Enabled={}", ipsEnabled)
.c_str());
parmsChanged = true;
}
ipsEntry = ipsProperties.find(IPS_ENTER_UTIL);
if (ipsEntry != ipsProperties.end())
{
enterUtil = std::get<uint8_t>(ipsEntry->second);
log<level::INFO>(
std::format("Idle Power Saver change: Enter Util={}%", enterUtil)
.c_str());
parmsChanged = true;
}
ipsEntry = ipsProperties.find(IPS_ENTER_TIME);
if (ipsEntry != ipsProperties.end())
{
std::chrono::milliseconds ms(std::get<uint64_t>(ipsEntry->second));
enterTime =
std::chrono::duration_cast<std::chrono::seconds>(ms).count();
log<level::INFO>(
std::format("Idle Power Saver change: Enter Time={}sec", enterTime)
.c_str());
parmsChanged = true;
}
ipsEntry = ipsProperties.find(IPS_EXIT_UTIL);
if (ipsEntry != ipsProperties.end())
{
exitUtil = std::get<uint8_t>(ipsEntry->second);
log<level::INFO>(
std::format("Idle Power Saver change: Exit Util={}%", exitUtil)
.c_str());
parmsChanged = true;
}
ipsEntry = ipsProperties.find(IPS_EXIT_TIME);
if (ipsEntry != ipsProperties.end())
{
std::chrono::milliseconds ms(std::get<uint64_t>(ipsEntry->second));
exitTime = std::chrono::duration_cast<std::chrono::seconds>(ms).count();
log<level::INFO>(
std::format("Idle Power Saver change: Exit Time={}sec", exitTime)
.c_str());
parmsChanged = true;
}
if (parmsChanged)
{
if (exitUtil == 0)
{
// Setting the exitUtil to 0 will force restoring the default IPS
// parmeters (0 is not valid exit utilization)
log<level::INFO>(
"Idle Power Saver Exit Utilization is 0%. Restoring default parameters");
// Read the default IPS parameters, write persistent file and update
// DBus
useDefaultIPSParms();
}
else
{
// Update persistant data with new DBus values
persistedData.updateIPS(ipsEnabled, enterUtil, enterTime, exitUtil,
exitTime);
}
// Trigger IPS data to get sent to the OCC
sendIpsData();
}
return;
}
/** @brief Get the Idle Power Saver properties from persisted data
* @return true if IPS parameters were read
*/
bool PowerMode::getIPSParms(bool& ipsEnabled, uint8_t& enterUtil,
uint16_t& enterTime, uint8_t& exitUtil,
uint16_t& exitTime)
{
// Defaults:
ipsEnabled = true; // Enabled
enterUtil = 8; // Enter Utilization (8%)
enterTime = 240; // Enter Delay Time (240s)
exitUtil = 12; // Exit Utilization (12%)
exitTime = 10; // Exit Delay Time (10s)
if (!persistedData.getIPS(ipsEnabled, enterUtil, enterTime, exitUtil,
exitTime))
{
// Persistent data not initialized, read defaults and update DBus
if (!initPersistentData())
{
// Unable to read defaults from entity manager yet
return false;
}
persistedData.getIPS(ipsEnabled, enterUtil, enterTime, exitUtil,
exitTime);
}
if (enterUtil > exitUtil)
{
log<level::ERR>(
std::format(
"ERROR: Idle Power Saver Enter Utilization ({}%) is > Exit Utilization ({}%) - using Exit for both",
enterUtil, exitUtil)
.c_str());
enterUtil = exitUtil;
}
return true;
}
// Set the Idle Power Saver data on DBus
bool PowerMode::updateDbusIPS(const bool enabled, const uint8_t enterUtil,
const uint16_t enterTime, const uint8_t exitUtil,
const uint16_t exitTime)
{
// true = skip update signal
IpsInterface::setPropertyByName(IPS_ENABLED_PROP, enabled, true);
IpsInterface::setPropertyByName(IPS_ENTER_UTIL, enterUtil, true);
// Convert time from seconds to ms
uint64_t msTime = enterTime * 1000;
IpsInterface::setPropertyByName(IPS_ENTER_TIME, msTime, true);
IpsInterface::setPropertyByName(IPS_EXIT_UTIL, exitUtil, true);
msTime = exitTime * 1000;
IpsInterface::setPropertyByName(IPS_EXIT_TIME, msTime, true);
return true;
}
// Send Idle Power Saver config data to the master OCC
CmdStatus PowerMode::sendIpsData()
{
if (!masterActive || !masterOccSet)
{
// Nothing to do
return CmdStatus::SUCCESS;
}
if (!isPowerVM())
{
// Idle Power Saver data is only supported on PowerVM systems
log<level::DEBUG>(
"PowerMode::sendIpsData: SET_CFG_DATA[IPS] does not get sent on non-PowerVM systems");
return CmdStatus::SUCCESS;
}
bool ipsEnabled;
uint8_t enterUtil, exitUtil;
uint16_t enterTime, exitTime;
getIPSParms(ipsEnabled, enterUtil, enterTime, exitUtil, exitTime);
log<level::INFO>(
std::format(
"Idle Power Saver Parameters: enabled:{}, enter:{}%/{}s, exit:{}%/{}s",
ipsEnabled, enterUtil, enterTime, exitUtil, exitTime)
.c_str());
std::vector<std::uint8_t> cmd, rsp;
cmd.reserve(12);
cmd.push_back(uint8_t(CmdType::SET_CONFIG_DATA));
cmd.push_back(0x00); // Data Length (2 bytes)
cmd.push_back(0x09); //
cmd.push_back(0x11); // Config Format: IPS Settings
cmd.push_back(0x00); // Version
cmd.push_back(ipsEnabled ? 1 : 0); // IPS Enable
cmd.push_back(enterTime >> 8); // Enter Delay Time
cmd.push_back(enterTime & 0xFF); //
cmd.push_back(enterUtil); // Enter Utilization
cmd.push_back(exitTime >> 8); // Exit Delay Time
cmd.push_back(exitTime & 0xFF); //
cmd.push_back(exitUtil); // Exit Utilization
log<level::INFO>(std::format("PowerMode::sendIpsData: SET_CFG_DATA[IPS] "
"command to OCC{} ({} bytes)",
occInstance, cmd.size())
.c_str());
CmdStatus status = occCmd->send(cmd, rsp);
if (status == CmdStatus::SUCCESS)
{
if (rsp.size() == 5)
{
if (RspStatus::SUCCESS != RspStatus(rsp[2]))
{
log<level::ERR>(
std::format(
"PowerMode::sendIpsData: SET_CFG_DATA[IPS] failed with status 0x{:02X}",
rsp[2])
.c_str());
dump_hex(rsp);
status = CmdStatus::FAILURE;
}
}
else
{
log<level::ERR>(
"PowerMode::sendIpsData: INVALID SET_CFG_DATA[IPS] response");
dump_hex(rsp);
status = CmdStatus::FAILURE;
}
}
else
{
log<level::ERR>(
std::format(
"PowerMode::sendIpsData: SET_CFG_DATA[IPS] with status={}",
status)
.c_str());
}
return status;
}
// Print the current values
void OccPersistData::print()
{
if (modeData.modeInitialized)
{
log<level::INFO>(
std::format(
"OccPersistData: Mode: 0x{:02X}, OEM Mode Data: {} (0x{:04X} Locked{})",
modeData.mode, modeData.oemModeData, modeData.oemModeData,
modeData.modeLocked)
.c_str());
}
if (modeData.ipsInitialized)
{
log<level::INFO>(
std::format(
"OccPersistData: IPS enabled:{}, enter:{}%/{}s, exit:{}%/{}s",
modeData.ipsEnabled, modeData.ipsEnterUtil,
modeData.ipsEnterTime, modeData.ipsExitUtil,
modeData.ipsExitTime)
.c_str());
}
}
// Saves the OEM mode data in the filesystem using cereal.
void OccPersistData::save()
{
std::filesystem::path opath =
std::filesystem::path{OCC_CONTROL_PERSIST_PATH} / powerModeFilename;
if (!std::filesystem::exists(opath.parent_path()))
{
std::filesystem::create_directory(opath.parent_path());
}
log<level::DEBUG>(
std::format(
"OccPersistData::save: Writing Power Mode persisted data to {}",
opath.c_str())
.c_str());
// print();
std::ofstream stream{opath.c_str()};
cereal::JSONOutputArchive oarchive{stream};
oarchive(modeData);
}
// Loads the OEM mode data in the filesystem using cereal.
void OccPersistData::load()
{
std::filesystem::path ipath =
std::filesystem::path{OCC_CONTROL_PERSIST_PATH} / powerModeFilename;
if (!std::filesystem::exists(ipath))
{
modeData.modeInitialized = false;
modeData.ipsInitialized = false;
return;
}
log<level::DEBUG>(
std::format(
"OccPersistData::load: Reading Power Mode persisted data from {}",
ipath.c_str())
.c_str());
try
{
std::ifstream stream{ipath.c_str()};
cereal::JSONInputArchive iarchive(stream);
iarchive(modeData);
}
catch (const std::exception& e)
{
auto error = errno;
log<level::ERR>(
std::format("OccPersistData::load: failed to read {}, errno={}",
ipath.c_str(), error)
.c_str());
modeData.modeInitialized = false;
modeData.ipsInitialized = false;
}
// print();
}
// Called when PowerModeProperties defaults are available on DBus
void PowerMode::defaultsReady(sdbusplus::message_t& msg)
{
std::map<std::string, std::variant<std::string>> properties{};
std::string interface;
msg.read(interface, properties);
// If persistent data exists, then don't need to read defaults
if ((!persistedData.modeAvailable()) || (!persistedData.ipsAvailable()))
{
log<level::INFO>(
std::format(
"Default PowerModeProperties are now available (persistent modeAvail={}, ipsAvail={})",
persistedData.modeAvailable() ? 'y' : 'n',
persistedData.modeAvailable() ? 'y' : 'n')
.c_str());
// Read default power mode defaults and update DBus
initPersistentData();
}
}
// Get the default power mode from DBus and return true if success
bool PowerMode::getDefaultMode(SysPwrMode& defaultMode)
{
try
{
auto& bus = utils::getBus();
std::string path = "/";
std::string service =
utils::getServiceUsingSubTree(PMODE_DEFAULT_INTERFACE, path);
auto method = bus.new_method_call(service.c_str(), path.c_str(),
"org.freedesktop.DBus.Properties",
"Get");
method.append(PMODE_DEFAULT_INTERFACE, "PowerMode");
auto reply = bus.call(method);
std::variant<std::string> stateEntryValue;
reply.read(stateEntryValue);
auto propVal = std::get<std::string>(stateEntryValue);
const std::string fullModeString = PMODE_INTERFACE + ".PowerMode."s +
propVal;
defaultMode = powermode::convertStringToMode(fullModeString);
if (!VALID_POWER_MODE_SETTING(defaultMode))
{
log<level::ERR>(
std::format(
"PowerMode::getDefaultMode: Invalid default power mode found: {}",
defaultMode)
.c_str());
// If default was read but not valid, use Max Performance
defaultMode = SysPwrMode::MAX_PERF;
return true;
}
}
catch (const sdbusplus::exception_t& e)
{
log<level::ERR>(
std::format("Unable to read Default Power Mode: {}", e.what())
.c_str());
return false;
}
return true;
}
/* Get the default Idle Power Saver properties and return true if successful */
bool PowerMode::getDefaultIPSParms(bool& ipsEnabled, uint8_t& enterUtil,
uint16_t& enterTime, uint8_t& exitUtil,
uint16_t& exitTime)
{
// Defaults:
ipsEnabled = true; // Enabled
enterUtil = 8; // Enter Utilization (8%)
enterTime = 240; // Enter Delay Time (240s)
exitUtil = 12; // Exit Utilization (12%)
exitTime = 10; // Exit Delay Time (10s)
std::map<std::string, std::variant<bool, uint8_t, uint16_t, uint64_t>>
ipsProperties{};
// Get all IPS properties from DBus
try
{
auto& bus = utils::getBus();
std::string path = "/";
std::string service =
utils::getServiceUsingSubTree(PMODE_DEFAULT_INTERFACE, path);
auto method = bus.new_method_call(service.c_str(), path.c_str(),
"org.freedesktop.DBus.Properties",
"GetAll");
method.append(PMODE_DEFAULT_INTERFACE);
auto reply = bus.call(method);
reply.read(ipsProperties);
}
catch (const sdbusplus::exception_t& e)
{
log<level::ERR>(
std::format(
"Unable to read Default Idle Power Saver parameters so it will be disabled: {}",
e.what())
.c_str());
return false;
}
auto ipsEntry = ipsProperties.find("IdlePowerSaverEnabled");
if (ipsEntry != ipsProperties.end())
{
ipsEnabled = std::get<bool>(ipsEntry->second);
}
else
{
log<level::ERR>(
"PowerMode::getDefaultIPSParms could not find property: IdlePowerSaverEnabled");
}
ipsEntry = ipsProperties.find("EnterUtilizationPercent");
if (ipsEntry != ipsProperties.end())
{
enterUtil = std::get<uint64_t>(ipsEntry->second);
}
else
{
log<level::ERR>(
"PowerMode::getDefaultIPSParms could not find property: EnterUtilizationPercent");
}
ipsEntry = ipsProperties.find("EnterUtilizationDwellTime");
if (ipsEntry != ipsProperties.end())
{
enterTime = std::get<uint64_t>(ipsEntry->second);
}
else
{
log<level::ERR>(
"PowerMode::getDefaultIPSParms could not find property: EnterUtilizationDwellTime");
}
ipsEntry = ipsProperties.find("ExitUtilizationPercent");
if (ipsEntry != ipsProperties.end())
{
exitUtil = std::get<uint64_t>(ipsEntry->second);
}
else
{
log<level::ERR>(
"PowerMode::getDefaultIPSParms could not find property: ExitUtilizationPercent");
}
ipsEntry = ipsProperties.find("ExitUtilizationDwellTime");
if (ipsEntry != ipsProperties.end())
{
exitTime = std::get<uint64_t>(ipsEntry->second);
}
else
{
log<level::ERR>(
"PowerMode::getDefaultIPSParms could not find property: ExitUtilizationDwellTime");
}
if (enterUtil > exitUtil)
{
log<level::ERR>(
std::format(
"ERROR: Default Idle Power Saver Enter Utilization ({}%) is > Exit Utilization ({}%) - using Exit for both",
enterUtil, exitUtil)
.c_str());
enterUtil = exitUtil;
}
return true;
}
/* Read default IPS parameters, save them to the persistent file and update
DBus. Return true if successful */
bool PowerMode::useDefaultIPSParms()
{
// Read the default IPS parameters
bool ipsEnabled;
uint8_t enterUtil, exitUtil;
uint16_t enterTime, exitTime;
if (!getDefaultIPSParms(ipsEnabled, enterUtil, enterTime, exitUtil,
exitTime))
{
// Unable to read defaults
return false;
}
log<level::INFO>(
std::format(
"PowerMode::useDefaultIPSParms: Using default IPS parms: Enabled: {}, EnterUtil: {}%, EnterTime: {}s, ExitUtil: {}%, ExitTime: {}s",
ipsEnabled, enterUtil, enterTime, exitUtil, exitTime)
.c_str());
// Save IPS parms to the persistent file
persistedData.updateIPS(ipsEnabled, enterUtil, enterTime, exitUtil,
exitTime);
// Write IPS parms to DBus
return updateDbusIPS(ipsEnabled, enterUtil, enterTime, exitUtil, exitTime);
}
#ifdef POWER10
// Starts to watch for IPS active state changes.
bool PowerMode::openIpsFile()
{
bool rc = true;
fd = open(ipsStatusFile.c_str(), O_RDONLY | O_NONBLOCK);
const int open_errno = errno;
if (fd < 0)
{
log<level::ERR>(std::format("openIpsFile Error({})={} : File={}",
open_errno, strerror(open_errno),
ipsStatusFile.c_str())
.c_str());
close(fd);
using namespace sdbusplus::org::open_power::OCC::Device::Error;
report<OpenFailure>(
phosphor::logging::org::open_power::OCC::Device::OpenFailure::
CALLOUT_ERRNO(open_errno),
phosphor::logging::org::open_power::OCC::Device::OpenFailure::
CALLOUT_DEVICE_PATH(ipsStatusFile.c_str()));
// We are no longer watching the error
active(false);
watching = false;
rc = false;
// NOTE: this will leave the system not reporting IPS active state to
// Fan Controls, Until an APP reload, or IPL and we will attempt again.
}
return rc;
}
// Starts to watch for IPS active state changes.
void PowerMode::addIpsWatch(bool poll)
{
// open file and register callback on file if we are not currently watching,
// and if poll=true, and if we are the master.
if ((!watching) && poll)
{
// Open the file
if (openIpsFile())
{
// register the callback handler which sets 'watching'
registerIpsStatusCallBack();
}
}
}
// Stops watching for IPS active state changes.
void PowerMode::removeIpsWatch()
{
// NOTE: we want to remove event, close file, and IPS active false no
// matter what the 'watching' flags is set to.
// We are no longer watching the error
active(false);
watching = false;
// Close file
close(fd);
// clears sourcePtr in the event source.
eventSource.reset();
}
// Attaches the FD to event loop and registers the callback handler
void PowerMode::registerIpsStatusCallBack()
{
decltype(eventSource.get()) sourcePtr = nullptr;
auto r = sd_event_add_io(event.get(), &sourcePtr, fd, EPOLLPRI | EPOLLERR,
ipsStatusCallBack, this);
if (r < 0)
{
log<level::ERR>(std::format("sd_event_add_io: Error({})={} : File={}",
r, strerror(-r), ipsStatusFile.c_str())
.c_str());
using InternalFailure =
sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
report<InternalFailure>();
removeIpsWatch();
// NOTE: this will leave the system not reporting IPS active state to
// Fan Controls, Until an APP reload, or IPL and we will attempt again.
}
else
{
// puts sourcePtr in the event source.
eventSource.reset(sourcePtr);
// Set we are watching the error
watching = true;
}
}
// Static function to redirect to non static analyze event function to be
// able to read file and push onto dBus.
int PowerMode::ipsStatusCallBack(sd_event_source* /*es*/, int /*fd*/,
uint32_t /*revents*/, void* userData)
{
auto pmode = static_cast<PowerMode*>(userData);
pmode->analyzeIpsEvent();
return 0;
}
// Function to Read SysFs file change on IPS state and push on dBus.
void PowerMode::analyzeIpsEvent()
{
// Need to seek to START, else the poll returns immediately telling
// there is data to be read. if not done this floods the system.
auto r = lseek(fd, 0, SEEK_SET);
const int open_errno = errno;
if (r < 0)
{
// NOTE: upon file access error we can not just re-open file, we have to
// remove and add to watch.
removeIpsWatch();
addIpsWatch(true);
}
// if we are 'watching' that is the file seek, or the re-open passed.. we
// can read the data
if (watching)
{
// This file gets created when polling OCCs. A value or length of 0 is
// deemed success. That means we would disable IPS active on dbus.
char data;
bool ipsState = false;
const auto len = read(fd, &data, sizeof(data));
const int readErrno = errno;
if (len <= 0)
{
removeIpsWatch();
log<level::ERR>(
std::format("IPS state Read Error({})={} : File={} : len={}",
readErrno, strerror(readErrno),
ipsStatusFile.c_str(), len)
.c_str());
report<ReadFailure>(
phosphor::logging::org::open_power::OCC::Device::ReadFailure::
CALLOUT_ERRNO(readErrno),
phosphor::logging::org::open_power::OCC::Device::ReadFailure::
CALLOUT_DEVICE_PATH(ipsStatusFile.c_str()));
// NOTE: this will leave the system not reporting IPS active state
// to Fan Controls, Until an APP reload, or IPL and we will attempt
// again.
}
else
{
// Data returned in ASCII.
// convert to integer. atoi()
// from OCC_P10_FW_Interfaces spec
// Bit 6: IPS active 1 indicates enabled.
// Bit 7: IPS enabled. 1 indicates enabled.
// mask off bit 6 --> & 0x02
// Shift left one bit and store as bool. >> 1
ipsState = static_cast<bool>(((atoi(&data)) & 0x2) >> 1);
}
// This will only set IPS active dbus if different than current.
active(ipsState);
}
else
{
removeIpsWatch();
// If the Retry did not get to "watching = true" we already have an
// error log, just post trace.
log<level::ERR>(std::format("Retry on File seek Error({})={} : File={}",
open_errno, strerror(open_errno),
ipsStatusFile.c_str())
.c_str());
// NOTE: this will leave the system not reporting IPS active state to
// Fan Controls, Until an APP reload, or IPL and we will attempt again.
}
return;
}
// overrides read/write to powerMode dbus property.
Mode::PowerMode PowerMode::powerMode(Mode::PowerMode value)
{
if (persistedData.getModeLock())
{
log<level::INFO>("PowerMode::powerMode: mode property change blocked");
elog<NotAllowed>(xyz::openbmc_project::Common::NotAllowed::REASON(
"mode change not allowed due to lock"));
return value;
}
else
{
return Mode::powerMode(value);
}
}
#endif
/* Set dbus property to SAFE mode(true) or clear(false) only if different */
void PowerMode::updateDbusSafeMode(const bool safeModeReq)
{
log<level::DEBUG>(
std::format("PowerMode:updateDbusSafeMode: Update dbus state ({})",
safeModeReq)
.c_str());
// Note; this function checks and only updates if different.
Mode::safeMode(safeModeReq);
}
} // namespace powermode
} // namespace occ
} // namespace open_power