nvidia-gpu: enable gpu software inventory

harshit-aghera · harshit-aghera · commit b341fa2b68ff · 2026-01-21T10:53:11.000Z
The patch uses the MCTP VDM command to retrieve the GPU driver version and updates the DBus interface xyz.openbmc_project.Software.Version with this information at DBus object path /xyz/openbmc_project/software/. The patch also associates software inventory to the chassis inventory item. The GPU driver version is made available in Redfish at the URI /redfish/v1/UpdateService/FirmwareInventory/. Tested: Build an image for nvl32-obmc machine with the following patches cherry picked. https://gerrit.openbmc.org/c/openbmc/openbmc/+/85490 The patch cherry-picks the following patches that are currently under review. ``` 1. device tree https://lore.kernel.org/all/aRbLqH8pLWCQryhu@molberding.nvidia.com/ 2. mctpd patches CodeConstruct/mctp#85 3. u-boot changes https://lore.kernel.org/openbmc/20251121-msx4-v1-0-fc0118b666c1@nvidia.com/T/#t 4. kernel changes as specified in the openbmc patch (for espi) 5. entity-manager changes https://gerrit.openbmc.org/c/openbmc/entity-manager/+/85455 6. platform-init changes https://gerrit.openbmc.org/c/openbmc/platform-init/+/85456 7. spi changes https://lore.kernel.org/all/20251121-w25q01jv_fixup-v1-1-3d175050db73@nvidia.com/ ``` The GPU driver version shows up on the DBus. Change-Id: I712fe0952a02f36e386d3f37a5d4a8192ba641de Signed-off-by: Harshit Aghera <haghera@nvidia.com>
diff --git a/src/nvidia-gpu/NvidiaDriverInformation.cpp b/src/nvidia-gpu/NvidiaDriverInformation.cpp
@@ -0,0 +1,122 @@
+/*
+ * SPDX-FileCopyrightText: Copyright OpenBMC Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "NvidiaDriverInformation.hpp"
+
+#include "Utils.hpp"
+
+#include <MctpRequester.hpp>
+#include <NvidiaGpuMctpVdm.hpp>
+#include <OcpMctpVdm.hpp>
+#include <phosphor-logging/lg2.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+#include <sdbusplus/message/native_types.hpp>
+
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <string>
+#include <system_error>
+#include <vector>
+
+const std::string softwareInventoryPath = "/xyz/openbmc_project/software/";
+
+NvidiaDriverInformation::NvidiaDriverInformation(
+    std::shared_ptr<sdbusplus::asio::connection>& conn,
+    mctp::MctpRequester& mctpRequester, const std::string& name,
+    const sdbusplus::message::object_path& path, const uint8_t eid,
+    sdbusplus::asio::object_server& objectServer) :
+    eid(eid), conn(conn), mctpRequester(mctpRequester)
+{
+    const std::string dbusPath = softwareInventoryPath + escapeName(name);
+
+    versionInterface = objectServer.add_interface(
+        dbusPath, "xyz.openbmc_project.Software.Version");
+
+    versionInterface->register_property<std::string>("Version", "");
+
+    versionInterface->register_property<std::string>(
+        "Purpose", "xyz.openbmc_project.Software.Version.VersionPurpose.Other");
+
+    if (!versionInterface->initialize())
+    {
+        lg2::error(
+            "Failed to initialize Version interface for Driver Information for eid {EID}",
+            "EID", eid);
+    }
+
+    std::vector<Association> associations;
+    associations.emplace_back("running", "ran_on", path.parent_path());
+
+    associationInterface =
+        objectServer.add_interface(dbusPath, association::interface);
+
+    associationInterface->register_property("Associations", associations);
+
+    if (!associationInterface->initialize())
+    {
+        lg2::error(
+            "Failed to initialize Association interface for Driver Information for eid {EID}",
+            "EID", eid);
+    }
+}
+
+void NvidiaDriverInformation::processResponse(const std::error_code& ec,
+                                              std::span<const uint8_t> buffer)
+{
+    if (ec)
+    {
+        lg2::error(
+            "Error updating Driver Information for eid {EID} : sending message over MCTP failed, rc={RC}",
+            "EID", eid, "RC", ec.message());
+        return;
+    }
+
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode = 0;
+    gpu::DriverState driverState{};
+    std::string driverVersion;
+
+    const int rc = gpu::decodeGetDriverInformationResponse(
+        buffer, cc, reasonCode, driverState, driverVersion);
+
+    if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+    {
+        lg2::error(
+            "Error updating Driver Information for eid {EID} : decode failed, rc={RC}, cc={CC}, reasonCode={REASON}",
+            "EID", eid, "RC", rc, "CC", static_cast<uint8_t>(cc), "REASON",
+            reasonCode);
+        return;
+    }
+
+    versionInterface->set_property("Version", driverVersion);
+}
+
+void NvidiaDriverInformation::update()
+{
+    const int rc = gpu::encodeGetDriverInformationRequest(0, request);
+
+    if (rc != 0)
+    {
+        lg2::error(
+            "Error updating Driver Information for eid {EID} : encode failed, rc={RC}",
+            "EID", eid, "RC", rc);
+        return;
+    }
+
+    mctpRequester.sendRecvMsg(
+        eid, request,
+        [weak{weak_from_this()}](const std::error_code& ec,
+                                 std::span<const uint8_t> buffer) {
+            std::shared_ptr<NvidiaDriverInformation> self = weak.lock();
+            if (!self)
+            {
+                lg2::error("invalid reference to NvidiaDriverInformation");
+                return;
+            }
+            self->processResponse(ec, buffer);
+        });
+}
diff --git a/src/nvidia-gpu/NvidiaDriverInformation.hpp b/src/nvidia-gpu/NvidiaDriverInformation.hpp
@@ -0,0 +1,46 @@
+/*
+ * SPDX-FileCopyrightText: Copyright OpenBMC Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "MctpRequester.hpp"
+
+#include <NvidiaGpuMctpVdm.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+struct NvidiaDriverInformation :
+    public std::enable_shared_from_this<NvidiaDriverInformation>
+{
+  public:
+    NvidiaDriverInformation(
+        std::shared_ptr<sdbusplus::asio::connection>& conn,
+        mctp::MctpRequester& mctpRequester, const std::string& name,
+        const sdbusplus::message::object_path& path, uint8_t eid,
+        sdbusplus::asio::object_server& objectServer);
+
+    void update();
+
+  private:
+    void processResponse(const std::error_code& ec,
+                         std::span<const uint8_t> buffer);
+
+    uint8_t eid{};
+
+    std::shared_ptr<sdbusplus::asio::connection> conn;
+
+    mctp::MctpRequester& mctpRequester;
+
+    std::array<uint8_t, sizeof(ocp::accelerator_management::CommonRequest)>
+        request{};
+
+    std::shared_ptr<sdbusplus::asio::dbus_interface> versionInterface;
+    std::shared_ptr<sdbusplus::asio::dbus_interface> associationInterface;
+};
diff --git a/src/nvidia-gpu/NvidiaGpuDevice.cpp b/src/nvidia-gpu/NvidiaGpuDevice.cpp
@@ -11,6 +11,7 @@
 #include <Inventory.hpp>
 #include <MctpRequester.hpp>
 #include <NvidiaDeviceDiscovery.hpp>
+#include <NvidiaDriverInformation.hpp>
 #include <NvidiaGpuEnergySensor.hpp>
 #include <NvidiaGpuMctpVdm.hpp>
 #include <NvidiaGpuPowerPeakReading.hpp>
@@ -93,6 +94,9 @@ void GpuDevice::makeSensors()
         conn, mctpRequester, name + "_Voltage_0", path, eid, gpuVoltageSensorId,
         objectServer, std::vector<thresholds::Threshold>{});
 
+    driverInfo = std::make_shared<NvidiaDriverInformation>(
+        conn, mctpRequester, name, path, eid, objectServer);
+
     getTLimitThresholds();
 
     lg2::info("Added GPU {NAME} Sensors with chassis path: {PATH}.", "NAME",
@@ -210,6 +214,7 @@ void GpuDevice::read()
     peakPower->update();
     energySensor->update();
     voltageSensor->update();
+    driverInfo->update();
 
     waitTimer.expires_after(std::chrono::milliseconds(sensorPollMs));
     waitTimer.async_wait(
diff --git a/src/nvidia-gpu/NvidiaGpuDevice.hpp b/src/nvidia-gpu/NvidiaGpuDevice.hpp
@@ -11,6 +11,7 @@
 #include "NvidiaGpuPowerSensor.hpp"
 #include "NvidiaGpuSensor.hpp"
 
+#include <NvidiaDriverInformation.hpp>
 #include <NvidiaGpuEnergySensor.hpp>
 #include <NvidiaGpuPowerPeakReading.hpp>
 #include <NvidiaGpuVoltageSensor.hpp>
@@ -74,6 +75,7 @@ class GpuDevice : public std::enable_shared_from_this<GpuDevice>
     std::shared_ptr<NvidiaGpuPowerPeakReading> peakPower;
     std::shared_ptr<NvidiaGpuEnergySensor> energySensor;
     std::shared_ptr<NvidiaGpuVoltageSensor> voltageSensor;
+    std::shared_ptr<NvidiaDriverInformation> driverInfo;
 
     std::array<uint8_t, sizeof(gpu::ReadThermalParametersRequest)>
         thermalParamReqMsg{};
diff --git a/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp b/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp
@@ -14,6 +14,7 @@
 #include <cstdint>
 #include <cstring>
 #include <span>
+#include <string>
 #include <vector>
 
 namespace gpu
@@ -413,6 +414,74 @@ int decodeGetVoltageResponse(std::span<const uint8_t> buf,
     return 0;
 }
 
+int encodeGetDriverInformationRequest(uint8_t instanceId,
+                                      std::span<uint8_t> buf)
+{
+    if (buf.size() < sizeof(ocp::accelerator_management::CommonRequest))
+    {
+        return EINVAL;
+    }
+
+    auto* msg = reinterpret_cast<ocp::accelerator_management::CommonRequest*>(
+        buf.data());
+
+    ocp::accelerator_management::BindingPciVidInfo header{};
+    header.ocp_accelerator_management_msg_type =
+        static_cast<uint8_t>(ocp::accelerator_management::MessageType::REQUEST);
+    header.instance_id = instanceId &
+                         ocp::accelerator_management::instanceIdBitMask;
+    header.msg_type = static_cast<uint8_t>(MessageType::PLATFORM_ENVIRONMENTAL);
+
+    auto rc = packHeader(header, msg->msgHdr.hdr);
+
+    if (rc != 0)
+    {
+        return rc;
+    }
+
+    msg->command = static_cast<uint8_t>(
+        PlatformEnvironmentalCommands::GET_DRIVER_INFORMATION);
+    msg->data_size = 0;
+
+    return 0;
+}
+
+int decodeGetDriverInformationResponse(
+    std::span<const uint8_t> buf,
+    ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+    DriverState& driverState, std::string& driverVersion)
+{
+    auto rc =
+        ocp::accelerator_management::decodeReasonCodeAndCC(buf, cc, reasonCode);
+
+    if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+    {
+        return rc;
+    }
+
+    if (buf.size() < sizeof(GetDriverInformationResponse))
+    {
+        return EINVAL;
+    }
+
+    const auto* response =
+        reinterpret_cast<const GetDriverInformationResponse*>(buf.data());
+
+    const uint16_t dataSize = le16toh(response->hdr.data_size);
+
+    if (dataSize < sizeof(DriverState) + sizeof(char))
+    {
+        return EINVAL;
+    }
+
+    driverState = response->driverState;
+    const size_t versionSize =
+        buf.size() - sizeof(GetDriverInformationResponse);
+    driverVersion = std::string(&response->driverVersion, versionSize);
+
+    return 0;
+}
+
 int encodeGetInventoryInformationRequest(uint8_t instanceId, uint8_t propertyId,
                                          std::span<uint8_t> buf)
 {
diff --git a/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp b/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp
@@ -43,6 +43,7 @@ enum class PlatformEnvironmentalCommands : uint8_t
     GET_MAX_OBSERVED_POWER = 0x04,
     GET_CURRENT_ENERGY_COUNTER = 0x06,
     GET_INVENTORY_INFORMATION = 0x0C,
+    GET_DRIVER_INFORMATION = 0x0E,
     GET_VOLTAGE = 0x0F,
 };
 
@@ -106,6 +107,13 @@ enum class PciePortType : uint8_t
     DOWNSTREAM = 1,
 };
 
+enum class DriverState : uint8_t
+{
+    DRIVER_STATE_UNKNOWN = 0,
+    DRIVER_STATE_NOT_LOADED = 1,
+    DRIVER_STATE_LOADED = 2,
+};
+
 struct QueryDeviceIdentificationRequest
 {
     ocp::accelerator_management::CommonRequest hdr;
@@ -189,6 +197,13 @@ struct ListPCIePortsDownstreamPortsData
     uint8_t count;
 } __attribute__((packed));
 
+struct GetDriverInformationResponse
+{
+    ocp::accelerator_management::CommonResponse hdr;
+    DriverState driverState;
+    char driverVersion;
+} __attribute__((packed));
+
 struct GetInventoryInformationRequest
 {
     ocp::accelerator_management::CommonRequest hdr;
@@ -251,6 +266,14 @@ int decodeGetVoltageResponse(std::span<const uint8_t> buf,
                              ocp::accelerator_management::CompletionCode& cc,
                              uint16_t& reasonCode, uint32_t& voltage);
 
+int encodeGetDriverInformationRequest(uint8_t instanceId,
+                                      std::span<uint8_t> buf);
+
+int decodeGetDriverInformationResponse(
+    std::span<const uint8_t> buf,
+    ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+    DriverState& driverState, std::string& driverVersion);
+
 int encodeGetInventoryInformationRequest(uint8_t instanceId, uint8_t propertyId,
                                          std::span<uint8_t> buf);
 
diff --git a/src/nvidia-gpu/NvidiaGpuSensorMain.cpp b/src/nvidia-gpu/NvidiaGpuSensorMain.cpp
@@ -55,6 +55,7 @@ int main()
     sdbusplus::asio::object_server objectServer(systemBus, true);
     objectServer.add_manager("/xyz/openbmc_project/sensors");
     objectServer.add_manager("/xyz/openbmc_project/inventory");
+    objectServer.add_manager("/xyz/openbmc_project/software");
     systemBus->request_name("xyz.openbmc_project.GpuSensor");
 
     mctp::MctpRequester mctpRequester(io);
diff --git a/src/nvidia-gpu/meson.build b/src/nvidia-gpu/meson.build
@@ -2,6 +2,7 @@ gpusensor_sources = files(
     'Inventory.cpp',
     'MctpRequester.cpp',
     'NvidiaDeviceDiscovery.cpp',
+    'NvidiaDriverInformation.cpp',
     'NvidiaGpuDevice.cpp',
     'NvidiaGpuEnergySensor.cpp',
     'NvidiaGpuMctpVdm.cpp',
diff --git a/src/tests/test_NvidiaGpuSensorTest.cpp b/src/tests/test_NvidiaGpuSensorTest.cpp
