南向部件驱动适配教程GPU篇 ​

#ifndef __AWM_M11P_CARD_H__
#define __AWM_M11P_CARD_H__

#include "interface/pcie_card.h"
#include "interface/pcie_device.h"
#include <mc/engine.h>

namespace dev {

class awm_m11p_card : public mc::engine::object<awm_m11p_card> {
public:
    // MC_OBJECT宏定义：类名、对象类型、路径模式、接口列表
    MC_OBJECT(awm_m11p_card, "PCIeGpuCard",
              "/bmc/dev/Systems/1/PCIeGpuCard/${object_name}", 
              (PCIeDevice)(PCIeCard))
    awm_m11p_card()  = default;    // 构造函数
    ~awm_m11p_card() = default;    // 析构函数

    // 生命周期方法
    bool start();
    bool stop();
    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);
    bool replace_dynamic_property(mc::mutable_dict& object, const mc::dict& connector);

    // 接口成员变量
    PCIeDevice m_pcie_device;
    PCIeCard   m_pcie_card;
    uint8_t    SystemId;
};

} // namespace dev

#endif // __AWM_M11P_CARD_H__

#include "awm_m11p_card.h"
#include <mc/core/timer.h>
#include <mc/log.h>
#include <thread>
#include <vector>

namespace dev {

// 启动方法：启动GPU卡任务，本示例不涉及
bool awm_m11p_card::start() {
    return true;
}

// 停止方法：停止GPU卡任务并清理资源，本示例不涉及
bool awm_m11p_card::stop() {
    return true;
}

// 在运行时替换SR配置文件中的动态占位符为实际值，bmc.dev.PCIeDevice接口下存在需要替换的动态占位符
bool awm_m11p_card::replace_dynamic_property(mc::mutable_dict& object, const mc::dict& connector) {
    m_pcie_device.replace_dynamic_property(object, connector);
    return true;
}

// 初始化方法，调用replace_dynamic_property，确保对象初始化时使用的是替换后的实际值
bool awm_m11p_card::init(mc::mutable_dict& csr_object, const mc::dict& connector) {
    try {
        replace_dynamic_property(csr_object, connector);
        from_variant(csr_object, *this);
    } catch (const std::exception& e) {
        elog("awm_m11p_card init failed, exception: ${exception}", ("exception", e.what()));
        return false;
    }
    return true;
}

} // namespace dev

MC_REFLECT(dev::awm_m11p_card,
           ((SystemId, "SystemId"))((m_pcie_device, "bmc.dev.PCIeDevice"))((m_pcie_card,
                                                                            "bmc.dev.PCIeCard")))

#include "awm_m11p_gpu.h"
#include "mc/log.h"

namespace dev {

// 启动方法：启动GPU任务，本示例不涉及
bool awm_m11p_gpu::start() {
    return true;
}

// 停止方法：停止GPU任务并清理资源，本示例不涉及
bool awm_m11p_gpu::stop() {
    return true;
}

// 初始化方法
bool awm_m11p_gpu::init(mc::mutable_dict& config, const mc::dict& connector) {
    try {
        from_variant(config, *this);
    } catch (const std::exception& e) {
        elog("awm_m11p_gpu init failed, exception: ${exception}", ("exception", e.what()));
        return false;
    }
    return true;
}

// 恢复默认属性
bool awm_m11p_gpu::reset_default_properties() {
    m_processor.Presence                = false;
    m_gpu.InfoRomVersion                = "";
    m_gpu.BuildDate                     = "";
    m_gpu.UUID                          = "";
    m_gpu.Utilization                   = 0;
    m_gpu.TemperatureCelsius            = 0;
    m_gpu_power.PowerWatts              = 0;
    m_gpu_power.PowerBrakeState         = 255;
    m_gpu_power.ExternalPowerSufficient = 255;
    m_gpu_status.ECCModeEnabled         = 255;
    m_gpu_status.ECCModePendingEnabled  = 255;
    m_gpu_status.ResetRequired          = 255;

    return true;
}

} // namespace dev

MC_REFLECT(dev::awm_m11p_gpu,
           ((m_processor, "bmc.dev.Processor"))((m_gpu, "bmc.dev.Gpu"))(
               (m_gpu_power, "bmc.dev.Gpu.Power"))((m_gpu_status, "bmc.dev.Gpu.Status")))

void NetworkAdapter::start_ncsi_update_task_huawei(ncsi_over_mctp_hw_ptr ncsi_over_mctp,
                                                   mc::milliseconds      interval) {
    // 创建定时器实例
    m_ncsi_timer            = new mc::core::timer(this);
    // 记录协议实体地址，当驱动对象实现层在调用接口类时完成赋值
    m_ncsi_over_mctp_huawei = ncsi_over_mctp;
    // 具体的轮询动作
    m_ncsi_timer->timeout.connect([this]() {
        update_firmware_version_by_ncsi();
    });
    m_ncsi_timer->set_single_shot(false);
    // 启动轮询
    m_ncsi_timer->start(interval);
}

void NetworkAdapter::stop_ncsi_update_task() {
    if (m_ncsi_timer) {
        // 停止轮询
        m_ncsi_timer->stop();
        // 删除定时器实例
        delete m_ncsi_timer;
        m_ncsi_timer = nullptr;
    }
    if (m_ncsi_over_mctp_huawei) {
        m_ncsi_over_mctp_huawei = nullptr;
    }
}

#include "awm_m11p_card.h"
#include "awm_m11p_gpu.h"
#include "awm_m11p_memory.h"
#include "devmon/driver_abi.h"
#include "mc/log.h"
#include <iostream>
#include <memory>
#ifndef DEVICE_DRIVER_NAME
#define DEVICE_DRIVER_NAME "awm_m11p"
#endif

using namespace dev;

extern "C" {

// ============================================
// GPU卡对象ABI函数
// ============================================

// 创建GPU卡对象：分配内存并设置基本属性
driver_handle_t create_awm_m11p_card(void* service, const char* name) {
    // 参数检查
    // 创建awm_m11p_card对象
    // 设置service和对象名称
    // 返回对象指针
}

// 初始化GPU卡对象：加载配置
status_t init_awm_m11p_card(driver_handle_t device, void* csr_object, void* connector) {
    // 参数检查
    // 类型转换
    // 调用对象的init方法
    // 返回状态码
}

// 启动GPU卡对象：启动设备和协议
status_t start_awm_m11p_card(driver_handle_t device) {
    // 参数检查
    // 调用对象的start方法
    // 返回状态码
}

// 停止GPU卡对象：停止设备和清理资源
status_t stop_awm_m11p_card(driver_handle_t device) {
    // 参数检查
    // 调用对象的stop方法
    // 返回状态码
}

// ============================================
// GPU对象ABI函数
// ============================================

// 创建GPU对象：分配内存并设置基本属性
driver_handle_t create_awm_m11p_gpu(void* service, const char* name) {
    // 参数检查
    // 创建awm_m11p_card对象
    // 设置service和对象名称
    // 返回对象指针
}

// 初始化GPU对象：加载配置
status_t init_awm_m11p_gpu(driver_handle_t device, void* csr_object, void* connector) {
    // 参数检查
    // 类型转换
    // 调用对象的init方法
    // 返回状态码
}

// 启动GPU对象：启动设备和协议
status_t start_awm_m11p_gpu(driver_handle_t device) {
    // 参数检查
    // 调用对象的start方法
    // 返回状态码
}

// 停止GPU对象：停止设备和清理资源
status_t stop_awm_m11p_gpu(driver_handle_t device) {
    // 参数检查
    // 调用对象的stop方法
    // 返回状态码
}

// ============================================
// 内存对象ABI函数
// ============================================

// 创建内存对象：分配内存并设置基本属性
driver_handle_t create_awm_m11p_memory(void* service, const char* name) {
    // 参数检查
    // 创建awm_m11p_card对象
    // 设置service和对象名称
    // 返回对象指针
}

// 初始化内存对象：加载配置
status_t init_awm_m11p_memory(driver_handle_t device, void* csr_object, void* connector) {
    // 参数检查
    // 类型转换
    // 调用对象的init方法
    // 返回状态码
}

// 启动内存对象：启动设备和协议
status_t start_awm_m11p_memory(driver_handle_t device) {
    // 参数检查
    // 调用对象的start方法
    // 返回状态码
}

// 停止内存对象：停止设备和清理资源
status_t stop_awm_m11p_memory(driver_handle_t device) {
    // 参数检查
    // 调用对象的stop方法
    // 返回状态码
}

// ============================================
// 驱动注册
// ============================================

device_driver_t awm_m11p_card_device_driver = {.device_name = "PCIeGpuCard",  // 设备类型名（必须与DDS文件一致）
                                               .ctor        = create_awm_m11p_card,
                                               .init        = init_awm_m11p_card,
                                               .start       = start_awm_m11p_card,
                                               .stop        = stop_awm_m11p_card};

device_driver_t awm_m11p_gpu_device_driver = {.device_name = "GraphicsController",   // 设备类型名（必须与DDS文件一致）
                                              .ctor        = create_awm_m11p_gpu,
                                              .init        = init_awm_m11p_gpu,
                                              .start       = start_awm_m11p_gpu,
                                              .stop        = stop_awm_m11p_gpu};

device_driver_t awm_m11p_memory_device_driver = {.device_name = "Memory",   // 设备类型名（必须与DDS文件一致）
                                                 .ctor        = create_awm_m11p_memory,
                                                 .init        = init_awm_m11p_memory,
                                                 .start       = start_awm_m11p_memory,
                                                 .stop        = stop_awm_m11p_memory};

// 驱动数组：包含所有设备类型的驱动
device_driver_t awm_m11p_driver[] = {awm_m11p_card_device_driver, awm_m11p_gpu_device_driver,
                                     awm_m11p_memory_device_driver};

// 驱动注册函数：框架调用此函数获取驱动列表
status_t        register_device_driver(device_driver_t** device_driver, uint8_t* count) {
    *device_driver = awm_m11p_driver;
    *count         = sizeof(awm_m11p_driver) / sizeof(awm_m11p_driver[0]);
    return STATUS_OK;
}
}

class hi182x_test_service : public mc::engine::service {
public:
    hi182x_test_service(const std::string& name) : mc::engine::service(name) {
    }
};

// 该类继承自TestWithEngine，用于测试Hi182x网卡驱动的ABI接口
class Hi182xAbiTest : public mc::test::TestWithEngine {
public:
    // 测试套件初始化（所有测试用例执行前调用一次）
    static void SetUpTestSuite() {
        // 调用基类的SetUpTestSuite初始化测试引擎
        TestWithEngine::SetUpTestSuite();
        // 初始化并启动测试服务
        m_test_service.init();
        m_test_service.start();
        // 动态加载Hi182x驱动库
        load_driver();
    }
    
    // 测试套件清理（所有测试用例执行后调用一次）
    static void TearDownTestSuite() {
        // 停止测试服务
        m_test_service.stop();
        // 关闭动态库句柄，释放资源
        if (m_driver_handle != nullptr) {
            dlclose(m_driver_handle);
            m_driver_handle = nullptr;
        }
        // 清理测试引擎资源
        TestWithEngine::TearDownTestSuite();
    }

    // 单个测试用例初始化（每个测试用例执行前调用）
    void SetUp() override {
    }

    // 单个测试用例清理（每个测试用例执行后调用）
    void TearDown() override {
    }

    // 动态加载驱动库并注册设备驱动
    static void load_driver() {
        // 使用dlopen动态加载驱动库，RTLD_LAZY表示延迟绑定符号
        m_driver_handle = dlopen("./opt/bmc/drivers/libhisi_182x.so", RTLD_LAZY);
        if (m_driver_handle == nullptr) {
            MC_THROW(mc::system_exception, "Failed to load driver: ${error}", ("error", dlerror()));
        }
        // 从动态库中查找并获取register_device_driver函数
        register_device_driver_func func = reinterpret_cast<register_device_driver_func>(
            dlsym(m_driver_handle, "register_device_driver"));
        MC_ASSERT_THROW(func, mc::bad_function_call_exception,
                        "Failed to get export_device_driver function: ${error}",
                        ("error", dlerror()));
        // 调用驱动注册函数，获取设备驱动列表
        device_driver_t* devices       = nullptr;
        uint8_t          devices_count = 0;
        status_t         ret           = func(&devices, &devices_count);
        MC_ASSERT_THROW(ret == STATUS_OK, mc::bad_function_call_exception,
                        "Failed to get device driver manager: ${error}", ("error", ret));

         // 清空并重新填充设备驱动映射表
        m_devices.clear();
        // 预分配空间，提高性能
        m_devices.reserve(devices_count);
        // 遍历所有设备驱动类型，存储到映射表中（key为device_name，value为device_driver_t）
        for (uint8_t i = 0; i < devices_count; i++) {
            auto device_driver = std::make_shared<device_driver_t>(devices[i]);
            m_devices.emplace(device_driver->device_name, device_driver);
        }
    }
    // 连接器（connector）用于传递上级设备的信息给子设备
    mc::dict create_test_connector(uint8_t system_id, uint8_t position, uint8_t slot) {
        return mc::dict{{"SystemId", system_id}, {"Position", position}, {"Slot", slot}};
    }
    // 测试服务实例，提供引擎服务环境
    static hi182x_test_service                                               m_test_service;
    // 设备驱动映射表，key为设备类型名（如"PCIeNicCard"），value为设备驱动信息
    static std::unordered_map<std::string, std::shared_ptr<device_driver_t>> m_devices;
    // 动态库句柄，用于dlopen/dlclose操作
    static void*                                                             m_driver_handle;
};
// ========== 静态成员变量定义 ==========

// 初始化测试服务实例，服务名称为"bmc.kepler.test_hi182x"
// 该服务为测试提供引擎服务环境，支持设备对象的创建和管理
hi182x_test_service Hi182xAbiTest::m_test_service{"bmc.kepler.test_hi182x"};

// 初始化设备驱动映射表（默认为空）
// 在SetUpTestSuite中通过load_driver()填充，存储所有注册的设备驱动类型
// key: 设备类型名称（如"PCIeNicCard"、"NicPort"、"OpticalTransceiver"）
// value: 设备驱动信息（包含ctor、init、start、stop等函数指针）
std::unordered_map<std::string, std::shared_ptr<device_driver_t>> Hi182xAbiTest::m_devices;

// 初始化动态库句柄为nullptr
// 在SetUpTestSuite中通过dlopen加载驱动库后设置
// 在TearDownTestSuite中通过dlclose释放
void* Hi182xAbiTest::m_driver_handle = nullptr;