blob: 6d0fcd8b4eb2cbb707387a84a420abc9ee754dc1 [file] [log] [blame]
/*
* SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
* AFFILIATES. All rights reserved.
* SPDX-License-Identifier: Apache-2.0
*/
#include "NvidiaGpuEnergySensor.hpp"
#include "SensorPaths.hpp"
#include "Thresholds.hpp"
#include "Utils.hpp"
#include "sensor.hpp"
#include <bits/basic_string.h>
#include <MctpRequester.hpp>
#include <NvidiaDeviceDiscovery.hpp>
#include <NvidiaGpuMctpVdm.hpp>
#include <OcpMctpVdm.hpp>
#include <phosphor-logging/lg2.hpp>
#include <sdbusplus/asio/connection.hpp>
#include <sdbusplus/asio/object_server.hpp>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <string>
#include <utility>
#include <vector>
using namespace std::literals;
// Reading from the device is in millijoules and unit set on the dbus is Joules.
static constexpr double gpuEnergySensorMaxReading =
std::numeric_limits<uint64_t>::max() / 1000.0;
static constexpr double gpuEnergySensorMinReading = 0.0;
NvidiaGpuEnergySensor::NvidiaGpuEnergySensor(
std::shared_ptr<sdbusplus::asio::connection>& conn,
mctp::MctpRequester& mctpRequester, const std::string& name,
const std::string& sensorConfiguration, const uint8_t eid, uint8_t sensorId,
sdbusplus::asio::object_server& objectServer,
std::vector<thresholds::Threshold>&& thresholdData) :
Sensor(escapeName(name), std::move(thresholdData), sensorConfiguration,
"energy", false, true, gpuEnergySensorMaxReading,
gpuEnergySensorMinReading, conn),
eid(eid), sensorId{sensorId}, mctpRequester(mctpRequester),
objectServer(objectServer)
{
std::string dbusPath = sensorPathPrefix + "energy/"s + escapeName(name);
sensorInterface = objectServer.add_interface(
dbusPath, "xyz.openbmc_project.Sensor.Value");
for (const auto& threshold : thresholds)
{
std::string interface = thresholds::getInterface(threshold.level);
thresholdInterfaces[static_cast<size_t>(threshold.level)] =
objectServer.add_interface(dbusPath, interface);
}
association = objectServer.add_interface(dbusPath, association::interface);
setInitialProperties(sensor_paths::unitJoules);
}
NvidiaGpuEnergySensor::~NvidiaGpuEnergySensor()
{
for (const auto& iface : thresholdInterfaces)
{
objectServer.remove_interface(iface);
}
objectServer.remove_interface(sensorInterface);
objectServer.remove_interface(association);
}
void NvidiaGpuEnergySensor::checkThresholds()
{
thresholds::checkThresholds(this);
}
void NvidiaGpuEnergySensor::processResponse(int sendRecvMsgResult)
{
if (sendRecvMsgResult != 0)
{
lg2::error(
"Error updating Energy Sensor for eid {EID} and sensor id {SID} : sending message over MCTP failed, rc={RC}",
"EID", eid, "SID", sensorId, "RC", sendRecvMsgResult);
return;
}
ocp::accelerator_management::CompletionCode cc{};
uint16_t reasonCode = 0;
uint64_t energyValue = 0;
auto rc = gpu::decodeGetCurrentEnergyCounterResponse(
response, cc, reasonCode, energyValue);
if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
{
lg2::error(
"Error updating Energy Sensor for eid {EID} and sensor id {SID} : decode failed, rc={RC}, cc={CC}, reasonCode={RESC}",
"EID", eid, "SID", sensorId, "RC", rc, "CC", cc, "RESC",
reasonCode);
return;
}
// Reading from the device is in millijoules and unit set on the dbus
// is Joules.
updateValue(energyValue / 1000.0);
}
void NvidiaGpuEnergySensor::update()
{
auto rc = gpu::encodeGetCurrentEnergyCounterRequest(0, sensorId, request);
if (rc != 0)
{
lg2::error(
"Error updating Energy Sensor for eid {EID} and sensor id {SID} : encode failed, rc={RC}",
"EID", eid, "SID", sensorId, "RC", rc);
return;
}
mctpRequester.sendRecvMsg(
eid, request, response,
[this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
}