部件驱动接口模型设计 ​

// 自动生成文件: gen/include/device_tree/interface/PCIeDevice.h
#ifndef GEN_PCIe_DEVICE_INTERFACE_H
#define GEN_PCIe_DEVICE_INTERFACE_H

#include <device_tree/base.h>

namespace dev::gen {

/**
 * @brief PCIe设备基础接口
 *
 * 此接口由DDS配置自动生成，定义了PCIe设备的标准属性和方法。
 * 厂商实现应继承此接口并实现具体逻辑。
 */
class MC_API PCIeDevice : public mc::engine::interface<PCIeDevice> {
public:
    MC_INTERFACE("bmc.dev.PCIeDevice")

    property<std::string> DeviceName;        ///< 设备资源名称
    property<std::string> Location;          ///< 当前PCIe的物理位置
    property<uint8_t>     Slot;              ///< PCIe设备的物理槽位号
    property<uint8_t>     SocketId;          ///< PCIe设备所属CPU ID
    property<uint8_t>     SystemId;          ///< PCIe设备所属系统ID
    property<uint8_t>     Bus;               ///< PCIe Root Port的总线号
    property<uint8_t>     Device;            ///< PCIe Root Port的设备号
    property<uint8_t>     Function;          ///< PCIe Root Port的功能号
    property<std::string> SlotType;          ///< PCIe设备所在槽位的类型
    property<std::string> DeviceType;        ///< PCIe设备类型
    property<std::string> Model;             ///< PCIe标卡产品型号
    property<std::string> Manufacturer;      ///< 厂商
    property<std::string> PartNumber;        ///< 部件编码
    property<std::string> SerialNumber;      ///< 序列号
    property<std::string> FirmwareVersion;   ///< PCIe标卡的固件版本号
    property<uint8_t>     MaxPCIeType;       ///< 最大支持的PCIe接口规格
    property<uint8_t>     PCIeType;          ///< 实际的PCIe接口规格
    property<uint8_t>     MaxLanes;          ///< 支持的最大通道数
    property<uint8_t>     LaneInUse;         ///< 实际使用的通道数

    virtual bool SetRootBDF(uint8_t bus, uint8_t device, uint8_t function) = 0;
};
} // namespace dev::gen

#endif // GEN_PCIe_DEVICE_INTERFACE_H

// 厂商接口实现文件: drivers/pcie_nic_card/hisi/interface/pcie_device.cpp (节选)
namespace dev {

// 反射注册：将实现类的属性与 D-Bus 接口关联
MC_REFLECT(dev::PCIeDevice)

} // namespace dev

// 厂商实现文件: drivers/pcie_nic_card/hisi/interface/pcie_device.h
#ifndef PCIE_DEVICE_INTERFACE_H
#define PCIE_DEVICE_INTERFACE_H

#include <mc/engine/service.h>
#include <mc/timer.h>

#include <device_tree/interface/PCIeDevice.h>
#include <ncsi_over_mctp/ncsi_over_mctp_huawei.h>
#include <smbus/smbus.h>

namespace dev {

using smbus_obj_ptr = mc::shared_ptr<smbus>;

/**
 * @brief PCIe设备接口的海思厂商实现
 *
 * 继承 auto-generated 的 dev::gen::PCIeDevice 基类。
 * 厂商实现类需以 mc::engine::interface<实现类, 基类> 双模板参数形式继承，
 * 使接口同时具备厂商实现与生成基类的双重类型信息。
 */
class MC_API PCIeDevice : public mc::engine::interface<PCIeDevice, gen::PCIeDevice> {
public:
    PCIeDevice()  = default;
    ~PCIeDevice() = default;

public:
    // 实现基类虚方法
    bool SetRootBDF(uint8_t bus, uint8_t device, uint8_t function) override;

public:
    void set_smbus_obj(smbus_obj_ptr smbus_obj);
    bool set_slot_by_smbus(uint8_t slot);

private:
    smbus_obj_ptr m_smbus_obj;

public:
    void replace_dynamic_property(mc::mutable_dict& object, const mc::dict& connector);
};

} // namespace dev

#endif // PCIE_DEVICE_INTERFACE_H

// 厂商实现文件: drivers/pcie_nic_card/hisi/interface/pcie_device.cpp (节选)
namespace dev {

bool PCIeDevice::SetRootBDF(uint8_t bus, uint8_t device, uint8_t function)
{
    if (bus == 0 && device == 0 && function == 0) {
        std::cerr << "Error: Invalid BDF values" << std::endl;
        return false;
    }
    Bus      = bus;
    Device   = device;
    Function = function;

    return true;
}

void PCIeDevice::set_smbus_obj(smbus_obj_ptr smbus_obj)
{
    m_smbus_obj = smbus_obj;
}

// 反射注册：单参数形式，在 .cpp 中完成
MC_REFLECT(dev::PCIeDevice)

} // namespace dev

// 设备对象文件: drivers/pcie_nic_card/hisi/hi182x/hi182x_card.h
#ifndef HI182X_CARD_H
#define HI182X_CARD_H

#include <imu/imu.h>
#include <mc/engine.h>
#include <mc/timer.h>
#include <mctp/mctp.h>
#include <ncsi_over_mctp/ncsi_over_mctp_huawei.h>
#include <smbus/smbus.h>

#include "hi182x_port.h"
#include "interface/board.h"
#include "interface/cooling.h"
#include "interface/fru.h"
#include "interface/network_adapter.h"
// ... 其余接口头文件

namespace dev {
using ncsi_over_mctp_hw_ptr = std::shared_ptr<ncsi_over_mctp_huawei>;
using smbus_obj_ptr         = mc::shared_ptr<smbus>;
using imu_ptr               = std::shared_ptr<imu>;

class hi182x_card : public mc::engine::object<hi182x_card> {
public:
    // MC_OBJECT宏定义：类名 / 设备类型名 / 路径模式 / 支持的接口列表
    MC_OBJECT(
        hi182x_card, "PCIeNicCard", "/bmc/dev/Systems/1/PCIeNicCard/${object_name}",
        (PCIeDevice)(PCIeDevice_PCIeFunction)(PCIeDevice_Oem)(PCIeDevice_Status)(PCIeCard)(PCIeCard_Oem)(PCIeCard_Metrics)(NetworkAdapter)(NetworkAdapter_FaultStatus)(Cooling)(NetworkAdapter_Oem)(Board)(PCIeDevice_Bandwidth)(NetworkAdapter_LogCollection)(Fru))

    hi182x_card();
    ~hi182x_card();
    // 生命周期方法（非虚，不带 override）
    bool start();
    bool stop();
    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);
    void init_network_ports();
    void replace_dynamic_property(mc::mutable_dict& object, const mc::dict& connector);

    // === 接口实例（组合模式） ===
    NetworkAdapter_Oem           m_network_adapter_oem;
    PCIeDevice                   m_pcie_device;
    PCIeDevice_PCIeFunction      m_pcie_device_pcie_function;
    PCIeDevice_Oem               m_pcie_device_oem;
    PCIeDevice_Status            m_pcie_device_status;
    PCIeCard                     m_pcie_card;
    PCIeCard_Oem                 m_pcie_card_oem;
    PCIeCard_Metrics             m_pcie_card_metrics;
    Cooling                      m_cooling;
    NetworkAdapter               m_network_adapter;
    NetworkAdapter_FaultStatus   m_network_adapter_fault_status;
    Board                        m_board;
    PCIeDevice_Bandwidth         m_pcie_device_bandwidth;
    NetworkAdapter_LogCollection m_network_adapter_log_collection;
    Fru                          m_fru;
    uint8_t                      m_system_id;

private:
    std::vector<hi182x_port*> m_network_ports;

    // === 协议管理 ===
    bool                  start_ncsi_protocol();
    void                  stop_ncsi_update_task();
    bool                  start_smbus_protocol();
    bool                  init_smbus_protocol();
    bool                  init_imu_protocol();
    bool                  start_protocol();
    ref_chip_ptr          m_ref_chip;
    smbus_obj_ptr         m_smbus_obj;
    imu_ptr               m_imu_obj;
    ncsi_over_mctp_hw_ptr m_ncsi_over_mctp_huawei;
    mc::milliseconds      m_interval       = mc::milliseconds(5000);
    mc::milliseconds      m_smbus_interval = mc::milliseconds(5000);
    mc::shared_ptr<mctp>  m_mctp_object;
};

} // namespace dev

// MC_REFLECT定义：建立接口成员与 D-Bus 接口名的映射
MC_REFLECT(dev::hi182x_card,
    ((m_system_id, "SystemId"))((m_pcie_device, "bmc.dev.PCIeDevice"))
    ((m_pcie_device_pcie_function, "bmc.dev.PCIeDevice.PCIeFunction"))
    ((m_pcie_device_oem, "bmc.dev.PCIeDevice.Oem"))
    ((m_pcie_device_status, "bmc.dev.PCIeDevice.Status"))
    ((m_pcie_card, "bmc.dev.PCIeCard"))((m_pcie_card_oem, "bmc.dev.PCIeCard.Oem"))
    ((m_pcie_card_metrics, "bmc.dev.PCIeCard.Metrics"))
    ((m_network_adapter, "bmc.dev.NetworkAdapter"))
    ((m_network_adapter_fault_status, "bmc.dev.NetworkAdapter.FaultStatus"))
    ((m_cooling, "bmc.dev.Cooling"))((m_network_adapter_oem, "bmc.dev.NetworkAdapter.Oem"))
    ((m_board, "bmc.dev.Board"))((m_pcie_device_bandwidth, "bmc.dev.PCIeDevice.Bandwidth"))
    ((m_fru, "bmc.dev.Fru"))
    ((m_network_adapter_log_collection, "bmc.dev.NetworkAdapter.LogCollection")))

#endif // HI182X_CARD_H

// 通过对象名前缀识别设备类型，使用 dynamic_cast 并校验空指针
for (auto& object : objects) {
    std::string sub_name = object->get_name();
    if (sub_name.substr(0, sub_name.find_first_of("_")) == "NicPort") {
        auto* port = dynamic_cast<hi182x_port*>(object.get());
        if (port == nullptr) {
            elog("hi182x_card child ${name} is not hi182x_port, skip", ("name", sub_name));
            continue;
        }
        ilog("hi182x_card init network port ${name}", ("name", sub_name));
        m_network_ports.push_back(port);
    }
}

// drivers/pcie_gpu_card/nvidia/interface/gpu.h
#ifndef NVIDIA_INTERFACE_GPU_H
#define NVIDIA_INTERFACE_GPU_H

#include <device_tree/interface/Gpu.h>

namespace dev {

/**
 * @brief GPU接口的NVIDIA厂商实现
 */
class Gpu : public mc::engine::interface<Gpu, gen::Gpu> {
public:
    // 实现基类虚方法
    bool Initialize() override {
        // NVIDIA特定的初始化逻辑
        return init_nvidia_gpu();
    }

    bool GetStatus() override {
        // 通过NVIDIA驱动获取GPU状态
        return query_nvidia_status();
    }

private:
    bool init_nvidia_gpu();
    bool query_nvidia_status();
};

} // namespace dev

#endif // NVIDIA_INTERFACE_GPU_H

// drivers/pcie_gpu_card/nvidia/tesla_t4/tesla_t4_card.h
#ifndef NVIDIA_TESLA_T4_CARD_H
#define NVIDIA_TESLA_T4_CARD_H

#include <mc/engine/object.h>
#include "drivers/pcie_gpu_card/nvidia/interface/gpu.h"
#include "drivers/pcie_gpu_card/nvidia/interface/pcie_device.h"

namespace dev {

class tesla_t4_card : public mc::engine::object<tesla_t4_card> {
public:
    MC_OBJECT(
        tesla_t4_card,
        "PCIeGpuCard",
        "/bmc/dev/Systems/1/PCIeGpuCard/${object_name}",
        (PCIeDevice)(PCIeCard)(Board))

    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);
    bool start();
    bool stop();

    // 接口实例
    dev::PCIeDevice m_pcie_device;
    dev::PCIeCard m_pcie_card;
    dev::Gpu m_gpu;
    dev::Board m_board;
};

} // namespace dev

MC_REFLECT(dev::tesla_t4_card,
    ((m_pcie_device, "bmc.dev.PCIeDevice"))
    ((m_pcie_card, "bmc.dev.PCIeCard"))
    ((m_gpu, "bmc.dev.Gpu"))
    ((m_board, "bmc.dev.Board"))
)

#endif // NVIDIA_TESLA_T4_CARD_H

// drivers/pcie_gpu_card/nvidia/tesla_t4/tesla_t4_abi.cpp
#include <devmon/driver_abi.h>
#include "tesla_t4_card.h"

extern "C" {

driver_handle_t create_tesla_t4_card(void* service, const char* name) {
    try {
        if (service == nullptr || name == nullptr) {
            return nullptr;
        }

        auto* device = new dev::tesla_t4_card();
        device->set_service(static_cast<mc::engine::service*>(service));
        device->set_object_name(name);
        return (void*)device;
    } catch (const std::exception& e) {
        elog("Error creating tesla_t4_card: ${error}", ("error", e.what()));
        return nullptr;
    }
}

status_t init_tesla_t4_card(driver_handle_t device, void* csr_object, void* connector) {
    if (device == nullptr || csr_object == nullptr || connector == nullptr) {
        return STATUS_ERROR;
    }

    auto* device_object = static_cast<dev::tesla_t4_card*>(device);
    auto* csr_object_ptr = static_cast<mc::mutable_dict*>(csr_object);
    auto* connector_ptr = static_cast<mc::dict*>(connector);

    bool ret = device_object->init(*csr_object_ptr, *connector_ptr);
    return ret ? STATUS_OK : STATUS_ERROR;
}

status_t start_tesla_t4_card(driver_handle_t device) {
    if (device == nullptr) {
        return STATUS_ERROR;
    }
    auto* device_object = static_cast<dev::tesla_t4_card*>(device);
    bool ret = device_object->start();
    return ret ? STATUS_OK : STATUS_ERROR;
}

status_t stop_tesla_t4_card(driver_handle_t device) {
    if (device == nullptr) {
        return STATUS_ERROR;
    }
    auto* device_object = static_cast<dev::tesla_t4_card*>(device);
    bool ret = device_object->stop();
    return ret ? STATUS_OK : STATUS_ERROR;
}

device_driver_t tesla_t4_card_driver = {
    .device_name = "PCIeGpuCard",
    .ctor = create_tesla_t4_card,
    .init = init_tesla_t4_card,
    .start = start_tesla_t4_card,
    .stop = stop_tesla_t4_card
};

status_t register_device_driver(device_driver_t** device_driver, uint8_t* count) {
    *device_driver = &tesla_t4_card_driver;
    *count = 1;
    return STATUS_OK;
}

} // extern "C"

// ✅ 推荐：清晰的接口实现
class PCIeDevice : public mc::engine::interface<PCIeDevice, gen::PCIeDevice> {
public:
    // 1. 实现所有虚方法
    bool SetRootBDF(uint8_t bus, uint8_t device, uint8_t function) override {
        // 参数验证
        if (!validate_bdf(bus, device, function)) {
            return false;
        }

        // 更新生成基类中的属性
        Bus      = bus;
        Device   = device;
        Function = function;

        return true;
    }

private:
    // 2. 使用私有方法封装复杂逻辑
    bool validate_bdf(uint8_t bus, uint8_t device, uint8_t function) {
        return !(bus == 0 && device == 0 && function == 0);
    }
};

// ❌ 不推荐：不完整的实现
class PCIeDevice : public mc::engine::interface<PCIeDevice, gen::PCIeDevice> {
public:
    // 缺少虚方法实现，导致编译错误
    // 缺少日志记录
    // 缺少错误处理
};

// ✅ 推荐：标准的设备对象模式
class hi182x_card : public mc::engine::object<hi182x_card> {
public:
    // 1. 使用MC_OBJECT定义对象元数据
    MC_OBJECT(hi182x_card, "PCIeNicCard",
              "/bmc/dev/Systems/1/PCIeNicCard/${object_name}",
              (PCIeDevice)(NetworkAdapter)(Board))

    // 2. 实现标准生命周期方法
    bool init(mc::mutable_dict& csr_object, const mc::dict& connector) {
        // 初始化逻辑
        return true;
    }

    bool start() {
        // 启动逻辑
        return true;
    }

    bool stop() {
        // 停止逻辑
        return true;
    }

    // 3. 声明接口实例
    dev::PCIeDevice m_pcie_device;
    dev::NetworkAdapter m_network_adapter;
    dev::Board m_board;

private:
    // 4. 私有成员和辅助方法
    void init_ports();
    bool start_protocol();
};

// 5. 定义反射映射
MC_REFLECT(dev::hi182x_card,
    ((m_pcie_device, "bmc.dev.PCIeDevice"))
    ((m_network_adapter, "bmc.dev.NetworkAdapter"))
    ((m_board, "bmc.dev.Board"))
)

// 1. 优先使用属性提供的批量/只读访问接口
//    属性值通过 .get_value() 一次读取，避免重复反序列化
std::string model = m_pcie_device.Model.get_value().as<std::string>();

// 2. 缓存频繁访问的属性（按实际存在的属性为准，此处以 DeviceType 为例）
class PCIeDevice {
private:
    std::string               m_cached_device_type;
    bool                      m_device_type_cached = false;

public:
    const std::string& get_device_type() {
        if (!m_device_type_cached) {
            m_cached_device_type = DeviceType.get_value().as<std::string>();
            m_device_type_cached = true;
        }
        return m_cached_device_type;
    }
};