| 
43 | 43 | #include <sdbusplus/unpack_properties.hpp>  | 
44 | 44 | 
 
  | 
45 | 45 | #include <array>  | 
 | 46 | +#include <string>  | 
46 | 47 | #include <string_view>  | 
47 | 48 | #include <variant>  | 
 | 49 | +#include <vector>  | 
48 | 50 | 
 
  | 
49 | 51 | namespace redfish  | 
50 | 52 | {  | 
@@ -2166,66 +2168,112 @@ inline void getProvisioningStatus(std::shared_ptr<bmcweb::AsyncResp> asyncResp)  | 
2166 | 2168 | #endif  | 
2167 | 2169 | 
 
  | 
2168 | 2170 | /**  | 
2169 |  | - * @brief Translate the PowerMode to a response message.  | 
 | 2171 | + * @brief Translate the PowerMode string to enum value  | 
2170 | 2172 |  *  | 
2171 |  | - * @param[in] asyncResp  Shared pointer for generating response message.  | 
2172 |  | - * @param[in] modeValue  PowerMode value to be translated  | 
 | 2173 | + * @param[in]  modeString PowerMode string to be translated  | 
2173 | 2174 |  *  | 
2174 |  | - * @return None.  | 
 | 2175 | + * @return PowerMode enum  | 
2175 | 2176 |  */  | 
2176 |  | -inline void  | 
2177 |  | -    translatePowerMode(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,  | 
2178 |  | -                       const std::string& modeValue)  | 
 | 2177 | +inline computer_system::PowerMode  | 
 | 2178 | +    translatePowerModeString(const std::string& modeString)  | 
2179 | 2179 | {  | 
2180 | 2180 |     using PowerMode = computer_system::PowerMode;  | 
2181 | 2181 | 
 
  | 
2182 |  | -    if (modeValue == "xyz.openbmc_project.Control.Power.Mode.PowerMode.Static")  | 
 | 2182 | +    if (modeString == "xyz.openbmc_project.Control.Power.Mode.PowerMode.Static")  | 
2183 | 2183 |     {  | 
2184 |  | -        asyncResp->res.jsonValue["PowerMode"] = PowerMode::Static;  | 
 | 2184 | +        return PowerMode::Static;  | 
2185 | 2185 |     }  | 
2186 |  | -    else if (  | 
2187 |  | -        modeValue ==  | 
 | 2186 | +    if (modeString ==  | 
2188 | 2187 |         "xyz.openbmc_project.Control.Power.Mode.PowerMode.MaximumPerformance")  | 
2189 | 2188 |     {  | 
2190 |  | -        asyncResp->res.jsonValue["PowerMode"] = PowerMode::MaximumPerformance;  | 
 | 2189 | +        return PowerMode::MaximumPerformance;  | 
2191 | 2190 |     }  | 
2192 |  | -    else if (modeValue ==  | 
2193 |  | -             "xyz.openbmc_project.Control.Power.Mode.PowerMode.PowerSaving")  | 
 | 2191 | +    if (modeString ==  | 
 | 2192 | +        "xyz.openbmc_project.Control.Power.Mode.PowerMode.PowerSaving")  | 
2194 | 2193 |     {  | 
2195 |  | -        asyncResp->res.jsonValue["PowerMode"] = PowerMode::PowerSaving;  | 
 | 2194 | +        return PowerMode::PowerSaving;  | 
2196 | 2195 |     }  | 
2197 |  | -    else if (  | 
2198 |  | -        modeValue ==  | 
 | 2196 | +    if (modeString ==  | 
2199 | 2197 |         "xyz.openbmc_project.Control.Power.Mode.PowerMode.BalancedPerformance")  | 
2200 | 2198 |     {  | 
2201 |  | -        asyncResp->res.jsonValue["PowerMode"] = PowerMode::BalancedPerformance;  | 
 | 2199 | +        return PowerMode::BalancedPerformance;  | 
2202 | 2200 |     }  | 
2203 |  | -    else if (  | 
2204 |  | -        modeValue ==  | 
 | 2201 | +    if (modeString ==  | 
2205 | 2202 |         "xyz.openbmc_project.Control.Power.Mode.PowerMode.EfficiencyFavorPerformance")  | 
2206 | 2203 |     {  | 
2207 |  | -        asyncResp->res.jsonValue["PowerMode"] =  | 
2208 |  | -            PowerMode::EfficiencyFavorPerformance;  | 
 | 2204 | +        return PowerMode::EfficiencyFavorPerformance;  | 
2209 | 2205 |     }  | 
2210 |  | -    else if (  | 
2211 |  | -        modeValue ==  | 
 | 2206 | +    if (modeString ==  | 
2212 | 2207 |         "xyz.openbmc_project.Control.Power.Mode.PowerMode.EfficiencyFavorPower")  | 
2213 | 2208 |     {  | 
2214 |  | -        asyncResp->res.jsonValue["PowerMode"] = PowerMode::EfficiencyFavorPower;  | 
 | 2209 | +        return PowerMode::EfficiencyFavorPower;  | 
2215 | 2210 |     }  | 
2216 |  | -    else if (modeValue ==  | 
2217 |  | -             "xyz.openbmc_project.Control.Power.Mode.PowerMode.OEM")  | 
 | 2211 | +    if (modeString == "xyz.openbmc_project.Control.Power.Mode.PowerMode.OEM")  | 
2218 | 2212 |     {  | 
2219 |  | -        asyncResp->res.jsonValue["PowerMode"] = PowerMode::OEM;  | 
 | 2213 | +        return PowerMode::OEM;  | 
 | 2214 | +    }  | 
 | 2215 | +    // Any other values would be invalid  | 
 | 2216 | +    BMCWEB_LOG_ERROR("PowerMode value was not valid: {}", modeString);  | 
 | 2217 | +    return PowerMode::Invalid;  | 
 | 2218 | +}  | 
 | 2219 | + | 
 | 2220 | +inline void  | 
 | 2221 | +    afterGetPowerMode(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,  | 
 | 2222 | +                      const boost::system::error_code& ec,  | 
 | 2223 | +                      const dbus::utility::DBusPropertiesMap& properties)  | 
 | 2224 | +{  | 
 | 2225 | +    if (ec)  | 
 | 2226 | +    {  | 
 | 2227 | +        BMCWEB_LOG_ERROR("DBUS response error on PowerMode GetAll: {}", ec);  | 
 | 2228 | +        messages::internalError(asyncResp->res);  | 
 | 2229 | +        return;  | 
 | 2230 | +    }  | 
 | 2231 | + | 
 | 2232 | +    std::string powerMode;  | 
 | 2233 | +    const std::vector<std::string>* allowedModes = nullptr;  | 
 | 2234 | +    const bool success = sdbusplus::unpackPropertiesNoThrow(  | 
 | 2235 | +        dbus_utils::UnpackErrorPrinter(), properties, "PowerMode", powerMode,  | 
 | 2236 | +        "AllowedPowerModes", allowedModes);  | 
 | 2237 | + | 
 | 2238 | +    if (!success)  | 
 | 2239 | +    {  | 
 | 2240 | +        messages::internalError(asyncResp->res);  | 
 | 2241 | +        return;  | 
 | 2242 | +    }  | 
 | 2243 | + | 
 | 2244 | +    nlohmann::json::array_t modeList;  | 
 | 2245 | +    if (allowedModes == nullptr)  | 
 | 2246 | +    {  | 
 | 2247 | +        modeList.emplace_back("Static");  | 
 | 2248 | +        modeList.emplace_back("MaximumPerformance");  | 
 | 2249 | +        modeList.emplace_back("PowerSaving");  | 
2220 | 2250 |     }  | 
2221 | 2251 |     else  | 
2222 | 2252 |     {  | 
2223 |  | -        // Any other values would be invalid  | 
2224 |  | -        BMCWEB_LOG_DEBUG("PowerMode value was not valid: {}", modeValue);  | 
 | 2253 | +        for (const auto& aMode : *allowedModes)  | 
 | 2254 | +        {  | 
 | 2255 | +            computer_system::PowerMode modeValue =  | 
 | 2256 | +                translatePowerModeString(aMode);  | 
 | 2257 | +            if (modeValue == computer_system::PowerMode::Invalid)  | 
 | 2258 | +            {  | 
 | 2259 | +                messages::internalError(asyncResp->res);  | 
 | 2260 | +                continue;  | 
 | 2261 | +            }  | 
 | 2262 | +            modeList.emplace_back(modeValue);  | 
 | 2263 | +        }  | 
 | 2264 | +    }  | 
 | 2265 | +    asyncResp->res.jsonValue["PowerMode@Redfish.AllowableValues"] = modeList;  | 
 | 2266 | + | 
 | 2267 | +    BMCWEB_LOG_DEBUG("Current power mode: {}", powerMode);  | 
 | 2268 | +    const computer_system::PowerMode modeValue =  | 
 | 2269 | +        translatePowerModeString(powerMode);  | 
 | 2270 | +    if (modeValue == computer_system::PowerMode::Invalid)  | 
 | 2271 | +    {  | 
2225 | 2272 |         messages::internalError(asyncResp->res);  | 
 | 2273 | +        return;  | 
2226 | 2274 |     }  | 
 | 2275 | +    asyncResp->res.jsonValue["PowerMode"] = modeValue;  | 
2227 | 2276 | }  | 
2228 |  | - | 
2229 | 2277 | /**  | 
2230 | 2278 |  * @brief Retrieves system power mode  | 
2231 | 2279 |  *  | 
@@ -2282,25 +2330,14 @@ inline void getPowerMode(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)  | 
2282 | 2330 |             messages::internalError(asyncResp->res);  | 
2283 | 2331 |             return;  | 
2284 | 2332 |         }  | 
2285 |  | -        // Valid Power Mode object found, now read the current value  | 
2286 |  | -        sdbusplus::asio::getProperty<std::string>(  | 
 | 2333 | + | 
 | 2334 | +        // Valid Power Mode object found, now read the mode properties  | 
 | 2335 | +        sdbusplus::asio::getAllProperties(  | 
2287 | 2336 |             *crow::connections::systemBus, service, path,  | 
2288 |  | -            "xyz.openbmc_project.Control.Power.Mode", "PowerMode",  | 
 | 2337 | +            "xyz.openbmc_project.Control.Power.Mode",  | 
2289 | 2338 |             [asyncResp](const boost::system::error_code& ec2,  | 
2290 |  | -                        const std::string& pmode) {  | 
2291 |  | -            if (ec2)  | 
2292 |  | -            {  | 
2293 |  | -                BMCWEB_LOG_ERROR("DBUS response error on PowerMode Get: {}",  | 
2294 |  | -                                 ec2);  | 
2295 |  | -                messages::internalError(asyncResp->res);  | 
2296 |  | -                return;  | 
2297 |  | -            }  | 
2298 |  | - | 
2299 |  | -            asyncResp->res.jsonValue["PowerMode@Redfish.AllowableValues"] = {  | 
2300 |  | -                "Static", "MaximumPerformance", "PowerSaving"};  | 
2301 |  | - | 
2302 |  | -            BMCWEB_LOG_DEBUG("Current power mode: {}", pmode);  | 
2303 |  | -            translatePowerMode(asyncResp, pmode);  | 
 | 2339 | +                        const dbus::utility::DBusPropertiesMap& properties) {  | 
 | 2340 | +            afterGetPowerMode(asyncResp, ec2, properties);  | 
2304 | 2341 |         });  | 
2305 | 2342 |     });  | 
2306 | 2343 | }  | 
 | 
0 commit comments