| /* |
| * SPDX-FileCopyrightText: Copyright OpenBMC Authors |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "NvidiaGpuClockSpeedControl.hpp" |
| |
| #include "Inventory.hpp" |
| #include "NvidiaGpuControlErrors.hpp" |
| #include "NvidiaUtils.hpp" |
| #include "Utils.hpp" |
| |
| #include <MctpRequester.hpp> |
| #include <NvidiaGpuMctpVdm.hpp> |
| #include <OcpMctpVdm.hpp> |
| #include <boost/asio/error.hpp> |
| #include <boost/asio/io_context.hpp> |
| #include <phosphor-logging/lg2.hpp> |
| #include <sdbusplus/asio/object_server.hpp> |
| #include <sdbusplus/message/native_types.hpp> |
| |
| #include <chrono> |
| #include <cstdint> |
| #include <functional> |
| #include <limits> |
| #include <memory> |
| #include <optional> |
| #include <span> |
| #include <string> |
| #include <system_error> |
| #include <utility> |
| #include <vector> |
| |
| static constexpr const char* controlClockSpeedIfaceName = |
| "xyz.openbmc_project.Control.OperatingClockSpeed"; |
| static constexpr const char* controlClockSpeedPrefix = |
| "/xyz/openbmc_project/control/operatingclockspeed/"; |
| |
| static constexpr uint64_t mhzToHzFactor = 1'000'000; |
| |
| // Debounce window to coalesce the RequestedSpeedLimitMin and Max writes of a |
| // single PATCH (which arrive back to back) into one SetClockLimit. |
| static constexpr std::chrono::milliseconds setLimitDebounce{100}; |
| |
| NvidiaGpuClockSpeedControl::NvidiaGpuClockSpeedControl( |
| sdbusplus::asio::object_server& objectServer, const std::string& deviceName, |
| mctp::MctpRequester& mctpRequester, uint8_t eid, |
| boost::asio::io_context& io, std::shared_ptr<Inventory> inventory) : |
| inventory(std::move(inventory)), mctpRequester(mctpRequester), |
| name(escapeName(deviceName)), objectServer(objectServer), setLimitTimer(io), |
| eid(eid) |
| { |
| const int rc = gpu::encodeGetClockLimitRequest( |
| 0, gpu::ClockType::GRAPHICS_CLOCK, requestBuffer); |
| if (rc == 0) |
| { |
| requestEncoded = true; |
| } |
| else |
| { |
| lg2::error("Failed to encode clock limit request for {NAME}: rc={RC}", |
| "NAME", name, "RC", rc); |
| } |
| |
| const sdbusplus::object_path inventoryPath = inventoryPrefix / name; |
| const sdbusplus::object_path objPath(controlClockSpeedPrefix + name); |
| |
| controlClockSpeedInterface = |
| objectServer.add_interface(objPath.str, controlClockSpeedIfaceName); |
| |
| associationInterface = |
| objectServer.add_interface(objPath, association::interface); |
| std::vector<Association> associations; |
| associations.emplace_back("controlling", "controlled_by", inventoryPath); |
| associationInterface->register_property("Associations", associations); |
| if (!associationInterface->initialize()) |
| { |
| lg2::error( |
| "Error initializing Association interface for Clock Speed Control for {NAME}, eid={EID}", |
| "NAME", name, "EID", eid); |
| } |
| |
| controlClockSpeedInterface->register_property( |
| "PresentSpeedLimitMaxHz", std::numeric_limits<uint64_t>::max(), |
| sdbusplus::asio::PropertyPermission::readOnly); |
| controlClockSpeedInterface->register_property( |
| "PresentSpeedLimitMinHz", uint64_t{0}, |
| sdbusplus::asio::PropertyPermission::readOnly); |
| |
| controlClockSpeedInterface->register_property<uint64_t>( |
| "RequestedSpeedLimitMaxHz", std::numeric_limits<uint64_t>::max(), |
| std::bind_front( |
| &NvidiaGpuClockSpeedControl::handleRequestedSpeedLimitMaxHzSet, |
| this), |
| [this](uint64_t&) { return requestedMaxHz; }); |
| controlClockSpeedInterface->register_property<uint64_t>( |
| "RequestedSpeedLimitMinHz", std::numeric_limits<uint64_t>::max(), |
| std::bind_front( |
| &NvidiaGpuClockSpeedControl::handleRequestedSpeedLimitMinHzSet, |
| this), |
| [this](uint64_t&) { return requestedMinHz; }); |
| |
| if (!controlClockSpeedInterface->initialize()) |
| { |
| lg2::error( |
| "Error initializing OperatingClockSpeed interface for {NAME}, eid={EID}", |
| "NAME", name, "EID", eid); |
| } |
| } |
| |
| NvidiaGpuClockSpeedControl::~NvidiaGpuClockSpeedControl() |
| { |
| objectServer.remove_interface(associationInterface); |
| objectServer.remove_interface(controlClockSpeedInterface); |
| } |
| |
| void NvidiaGpuClockSpeedControl::update() |
| { |
| sendGetClockLimitRequest(); |
| } |
| |
| void NvidiaGpuClockSpeedControl::sendGetClockLimitRequest() |
| { |
| if (!requestEncoded) |
| { |
| return; |
| } |
| |
| mctpRequester.sendRecvMsg( |
| eid, requestBuffer, |
| [weak{weak_from_this()}](const std::error_code& ec, |
| std::span<const uint8_t> buffer) { |
| auto self = weak.lock(); |
| if (!self) |
| { |
| lg2::error("Invalid NvidiaGpuClockSpeedControl reference"); |
| return; |
| } |
| self->handleGetClockLimitResponse(ec, buffer); |
| }); |
| } |
| |
| void NvidiaGpuClockSpeedControl::handleGetClockLimitResponse( |
| const std::error_code& ec, std::span<const uint8_t> buffer) |
| { |
| if (setClockLimitReadbackPending) |
| { |
| // This response is the read-back for a completed SetClockLimit: the |
| // device's new state has now been observed, so open the coalesce gate. |
| // Done before the error returns below so a failed read-back cannot |
| // wedge the gate shut forever. Any writes that arrived while the set |
| // was in flight have re-armed setLimitTimer and dispatch on its next |
| // expiry, so no manual re-dispatch is needed here. |
| setClockLimitReadbackPending = false; |
| setClockLimitInflight = false; |
| } |
| |
| if (ec) |
| { |
| lg2::error("Error reading clock limit for {NAME}: MCTP failed, rc={RC}", |
| "NAME", name, "RC", ec.message()); |
| return; |
| } |
| |
| ocp::accelerator_management::CompletionCode cc{}; |
| uint16_t reasonCode = 0; |
| uint32_t requestedLimitMin = 0; |
| uint32_t requestedLimitMax = 0; |
| uint32_t presentLimitMin = 0; |
| uint32_t presentLimitMax = 0; |
| |
| int rc = gpu::decodeGetClockLimitResponse( |
| buffer, cc, reasonCode, requestedLimitMin, requestedLimitMax, |
| presentLimitMin, presentLimitMax); |
| |
| if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS) |
| { |
| lg2::error( |
| "Error decoding clock limit for {NAME}: rc={RC}, cc={CC}, reasonCode={REASON}", |
| "NAME", name, "RC", rc, "CC", static_cast<uint8_t>(cc), "REASON", |
| reasonCode); |
| return; |
| } |
| |
| const uint64_t newPresentMaxHz = |
| static_cast<uint64_t>(presentLimitMax) * mhzToHzFactor; |
| const uint64_t newPresentMinHz = |
| static_cast<uint64_t>(presentLimitMin) * mhzToHzFactor; |
| const uint64_t newRequestedMaxHz = |
| static_cast<uint64_t>(requestedLimitMax) * mhzToHzFactor; |
| const uint64_t newRequestedMinHz = |
| static_cast<uint64_t>(requestedLimitMin) * mhzToHzFactor; |
| |
| // PresentSpeedLimit*Hz are read-only, so set_property updates the stored |
| // value and emits PropertiesChanged only when it actually changes. |
| // RequestedSpeedLimit*Hz are client-writable; updating them via |
| // set_property would re-enter the client set-handler, so the member is the |
| // source of truth and the change signal is emitted directly. |
| controlClockSpeedInterface->set_property("PresentSpeedLimitMaxHz", |
| newPresentMaxHz); |
| controlClockSpeedInterface->set_property("PresentSpeedLimitMinHz", |
| newPresentMinHz); |
| if (newRequestedMaxHz != requestedMaxHz) |
| { |
| requestedMaxHz = newRequestedMaxHz; |
| controlClockSpeedInterface->signal_property("RequestedSpeedLimitMaxHz"); |
| } |
| if (newRequestedMinHz != requestedMinHz) |
| { |
| requestedMinHz = newRequestedMinHz; |
| controlClockSpeedInterface->signal_property("RequestedSpeedLimitMinHz"); |
| } |
| } |
| |
| int NvidiaGpuClockSpeedControl::handleRequestedSpeedLimitMaxHzSet( |
| const uint64_t& newMaxHz, uint64_t& /*current*/) |
| { |
| if (!inventory) |
| { |
| lg2::error( |
| "RequestedSpeedLimitMaxHz set rejected for eid {EID}: inventory not available", |
| "EID", eid); |
| throw Unavailable(); |
| } |
| |
| std::optional<uint64_t> minHw = inventory->getMinSpeedInHz(); |
| std::optional<uint64_t> maxHw = inventory->getMaxSpeedInHz(); |
| if (!minHw || !maxHw) |
| { |
| lg2::error( |
| "RequestedSpeedLimitMaxHz set rejected for eid {EID}: hardware min/max not yet known", |
| "EID", eid); |
| throw Unavailable(); |
| } |
| |
| if (newMaxHz < *minHw || newMaxHz > *maxHw) |
| { |
| lg2::error( |
| "RequestedSpeedLimitMaxHz set rejected for eid {EID}: value {VAL} out of range [{MIN}, {MAX}]", |
| "EID", eid, "VAL", newMaxHz, "MIN", *minHw, "MAX", *maxHw); |
| throw InvalidArgument(); |
| } |
| |
| // Record the requested max and arm the debounce timer. The actual |
| // SetClockLimit is issued once the burst settles, so a PATCH that sets |
| // both RequestedSpeedLimitMin and Max is coalesced into a single request. |
| // Do not touch requestedMaxHz here: the D-Bus value is only updated once |
| // the device confirms via a GetClockLimit response. |
| pendingMaxHz = newMaxHz; |
| armSetLimitTimer(); |
| |
| return 1; |
| } |
| |
| int NvidiaGpuClockSpeedControl::handleRequestedSpeedLimitMinHzSet( |
| const uint64_t& newMinHz, uint64_t& /*current*/) |
| { |
| if (!inventory) |
| { |
| lg2::error( |
| "RequestedSpeedLimitMinHz set rejected for eid {EID}: inventory not available", |
| "EID", eid); |
| throw Unavailable(); |
| } |
| |
| std::optional<uint64_t> minHw = inventory->getMinSpeedInHz(); |
| std::optional<uint64_t> maxHw = inventory->getMaxSpeedInHz(); |
| if (!minHw || !maxHw) |
| { |
| lg2::error( |
| "RequestedSpeedLimitMinHz set rejected for eid {EID}: hardware min/max not yet known", |
| "EID", eid); |
| throw Unavailable(); |
| } |
| |
| if (newMinHz < *minHw || newMinHz > *maxHw) |
| { |
| lg2::error( |
| "RequestedSpeedLimitMinHz set rejected for eid {EID}: value {VAL} out of range [{MIN}, {MAX}]", |
| "EID", eid, "VAL", newMinHz, "MIN", *minHw, "MAX", *maxHw); |
| throw InvalidArgument(); |
| } |
| |
| pendingMinHz = newMinHz; |
| armSetLimitTimer(); |
| |
| return 1; |
| } |
| |
| void NvidiaGpuClockSpeedControl::armSetLimitTimer() |
| { |
| setLimitTimer.expires_after(setLimitDebounce); |
| setLimitTimer.async_wait( |
| [weak{weak_from_this()}](const boost::system::error_code& ec) { |
| if (ec == boost::asio::error::operation_aborted) |
| { |
| // Superseded by a later set within the debounce window. |
| return; |
| } |
| std::shared_ptr<NvidiaGpuClockSpeedControl> self = weak.lock(); |
| if (!self) |
| { |
| return; |
| } |
| self->applyPendingClockLimit(); |
| }); |
| } |
| |
| void NvidiaGpuClockSpeedControl::applyPendingClockLimit() |
| { |
| if (setClockLimitInflight) |
| { |
| // A previous SetClockLimit is still in flight; retry once it lands. |
| armSetLimitTimer(); |
| return; |
| } |
| |
| const uint64_t minHz = pendingMinHz.value_or(requestedMinHz); |
| const uint64_t maxHz = pendingMaxHz.value_or(requestedMaxHz); |
| pendingMinHz.reset(); |
| pendingMaxHz.reset(); |
| |
| sendSetClockLimitRequest(static_cast<uint32_t>(minHz / mhzToHzFactor), |
| static_cast<uint32_t>(maxHz / mhzToHzFactor)); |
| } |
| |
| void NvidiaGpuClockSpeedControl::sendSetClockLimitRequest(uint32_t limitMinMHz, |
| uint32_t limitMaxMHz) |
| { |
| const int rc = gpu::encodeSetClockLimitRequest( |
| 0, gpu::ClockType::GRAPHICS_CLOCK, gpu::ClockLimitFlag::PERSISTENCE, |
| limitMinMHz, limitMaxMHz, setClockLimitRequestBuffer); |
| |
| if (rc != 0) |
| { |
| lg2::error( |
| "Error encoding SET_CLOCK_LIMIT request for eid {EID}, rc={RC}", |
| "EID", eid, "RC", rc); |
| return; |
| } |
| |
| setClockLimitInflight = true; |
| |
| mctpRequester.sendRecvMsg( |
| eid, setClockLimitRequestBuffer, |
| [weak{weak_from_this()}](const std::error_code& ec, |
| std::span<const uint8_t> buffer) { |
| auto self = weak.lock(); |
| if (!self) |
| { |
| lg2::error("Invalid NvidiaGpuClockSpeedControl reference"); |
| return; |
| } |
| self->handleSetClockLimitResponse(ec, buffer); |
| }); |
| } |
| |
| void NvidiaGpuClockSpeedControl::handleSetClockLimitResponse( |
| const std::error_code& ec, std::span<const uint8_t> buffer) |
| { |
| if (ec) |
| { |
| lg2::error("Error setting clock limit for eid {EID}: {MSG}", "EID", eid, |
| "MSG", ec.message()); |
| setClockLimitInflight = false; |
| return; |
| } |
| |
| ocp::accelerator_management::CompletionCode cc{}; |
| uint16_t reasonCode = 0; |
| const int rc = gpu::decodeSetClockLimitResponse(buffer, cc, reasonCode); |
| |
| if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS) |
| { |
| lg2::error( |
| "Error decoding SetClockLimit response for eid {EID}: rc={RC}, cc={CC}, reasonCode={RESC}", |
| "EID", eid, "RC", rc, "CC", static_cast<uint8_t>(cc), "RESC", |
| reasonCode); |
| setClockLimitInflight = false; |
| return; |
| } |
| |
| // The set succeeded; re-read from the device so requestedMin/MaxHz and |
| // presentMin/MaxHz reflect the new state without waiting for the next |
| // periodic poll. setClockLimitInflight stays set until this read-back's |
| // response lands so the coalesce gate does not reopen on stale state. |
| if (!requestEncoded) |
| { |
| // No read-back can be sent, so no response will ever arrive to reopen |
| // the coalesce gate; release it here to avoid wedging it shut. |
| setClockLimitInflight = false; |
| return; |
| } |
| setClockLimitReadbackPending = true; |
| sendGetClockLimitRequest(); |
| } |
