设备驱动开发指南 ​

// 以华为海思 hi182x 网卡为例（完整定义见 drivers/pcie_nic_card/hisi/hi182x/hi182x_card.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(
        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))

    // 接口实例 - 组合多个接口实现复杂功能（类型即接口名，与 MC_OBJECT 中声明一致）
    PCIeDevice                   m_pcie_device;
    PCIeDevice_PCIeFunction      m_pcie_device_pcie_function;
    NetworkAdapter               m_network_adapter;
    PCIeCard                     m_pcie_card;
    Board                        m_board;
    Cooling                      m_cooling;
    NetworkAdapter_FaultStatus   m_network_adapter_fault_status;
    PCIeDevice_Bandwidth         m_pcie_device_bandwidth;
    NetworkAdapter_LogCollection m_network_adapter_log_collection;

    // 子设备集合（原始指针由框架通过 get_children() 管理，驱动只做类型转换）
    std::vector<hi182x_port*> m_network_ports;

    // 协议实例（MCTP 使用 mc::shared_ptr，其余使用 std::shared_ptr）
    ncsi_over_mctp_hw_ptr m_ncsi_over_mctp_huawei;
    imu_ptr               m_imu_obj;
    smbus_obj_ptr         m_smbus_obj;
    mc::shared_ptr<mctp>  m_mctp_object;

    // 生命周期方法（实际签名）
    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);
    bool start();
    bool stop();
};
} // namespace dev

// PCIe网卡组合了多个接口
class hi182x_card {
    PCIeDevice                   m_pcie_device;               // PCIe设备接口
    PCIeDevice_PCIeFunction      m_pcie_device_pcie_function; // PCIe功能接口（BDF/VID/DID）
    NetworkAdapter               m_network_adapter;           // 网络适配器接口
    PCIeCard                     m_pcie_card;                 // PCIe卡接口
    Board                        m_board;                     // 板卡信息接口
    Cooling                      m_cooling;                   // 散热子接口（bmc.dev.Cooling）
    NetworkAdapter_FaultStatus   m_network_adapter_fault_status; // 故障状态子接口
    NetworkAdapter_LogCollection m_network_adapter_log_collection; // 日志收集子接口
    PCIeDevice_Bandwidth         m_pcie_device_bandwidth;     // 带宽监控子接口
};

// 1. 接口类继承 mc::engine::interface 并关联的 gen:: 基类
class PCIeDevice : public mc::engine::interface<PCIeDevice, gen::PCIeDevice> {
public:
    std::string DeviceName;
    std::string VendorId;
    std::string DeviceId;
    uint8_t Bus, Device, Function;
};

// 2. 设备对象注册反射信息：将成员与 D-Bus 接口名关联（与 hi182x_card.cpp 一致）
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")))

// 3. 运行时使用
mc::dict properties;
mc::reflect::to_variant(card->m_pcie_device, properties);   // 对象 -> JSON
card->m_pcie_device.DeviceName = "NewCard";                // 直接访问属性

// NCSI 标准命令通过 ncsi_over_mctp_standard 提供，需基于 MCTP 对象构造
mc::shared_ptr<mctp> mctp_obj =
    mc::make_shared<mctp>(this, mctp::init_phy_addr(0x01, 0x00, 0x00),
                          MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NCSI, "");
ncsi_over_mctp_standard ncsi(mctp_obj);

// 获取链路状态
ncsi_link_status_info_t link_status;
if (ncsi.get_link_status(DEFAULT_PACKAGE_ID, DEFAULT_CHANNEL_ID, &link_status)) {
    ilog("Link: ${status}, Speed: ${speed} Mbps",
         ("status", link_status.link_status ? "UP" : "DOWN")("speed", link_status.speed_mbps));
}

// 获取能力信息
ncsi_capabilities_info_t capability;
ncsi.get_capabilities(DEFAULT_PACKAGE_ID, DEFAULT_CHANNEL_ID, &capability);

// MCTP 对象无默认构造函数，需传入父对象、物理地址、消息类型和位置
uint16_t phy_addr = mctp::init_phy_addr(bus, device, function); // 静态方法计算物理地址
mc::shared_ptr<mctp> mctp_obj =
    mc::make_shared<mctp>(this, phy_addr, MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NCSI, "");

// 创建传输对象和端点对象，端点和传输就绪后回调初始化业务任务
mctp_obj->create_transport_and_endpoint(std::string(get_object_name()), [this]() {
    // 端点就绪后，启动 NCSI 等上层协议任务
});

// 发送请求（request 返回 bool，响应保存在 rsp 字符串中）
mc::dict ctx = {{"timeout", 1000}};
std::vector<uint8_t> request_data = {...};  // 填充请求数据
std::string rsp;
if (mctp_obj->request(ctx, request_data, 1000, rsp)) {
    // 处理响应...
}

// 1. 创建 MCTP 对象（NCSI over MCTP 基于 MCTP 传输层）
uint16_t phy_addr =
    mctp::init_phy_addr(m_pcie_device_pcie_function.BusNumber,
                        m_pcie_device_pcie_function.DeviceNumber,
                        m_pcie_device_pcie_function.FunctionNumber);
mc::shared_ptr<mctp> mctp_obj =
    mc::make_shared<mctp>(this, phy_addr, MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NCSI, "");

// 2. 通过 MCTP 对象构造华为扩展协议实例
ncsi_over_mctp_hw_ptr nom_hw = std::make_shared<ncsi_over_mctp_huawei>(mctp_obj);

// 3. 获取链路信息（package_id/channel_id 为入参，信息写入出参指针）
ncsi_link_info_t link_info;
if (nom_hw->get_link_info(DEFAULT_PACKAGE_ID, DEFAULT_CHANNEL_ID, &link_info)) {
    ilog("Link width: ${width}, speed: ${speed}",
         ("width", link_info.link_width)("speed", link_info.link_speed));
}

// 4. 获取芯片温度
uint16_t chip_temp = 0;
if (nom_hw->get_chip_temp(DEFAULT_PACKAGE_ID, DEFAULT_CHANNEL_ID, &chip_temp)) {
    ilog("Chip temperature: ${temp}", ("temp", chip_temp));
}

// 5. 在设备对象中，通常通过 mctp->create_transport_and_endpoint 回调中创建并绑定任务：
mctp_obj->create_transport_and_endpoint(std::string(get_object_name()), [this, mctp_obj]() {
    m_ncsi_over_mctp_huawei = std::make_shared<ncsi_over_mctp_huawei>(mctp_obj);
    m_network_adapter.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei, m_interval);
});

// 创建IMU对象（无默认构造函数，需传入服务指针）
imu_ptr m_imu_obj = std::make_shared<imu>(get_service());

// 准备请求
imu_pcie_device_req_t req = {
    .system_id        = m_system_id,
    .socket_id        = m_pcie_device.SocketId,
    .bus              = m_pcie_device_pcie_function.BusNumber,
    .device           = m_pcie_device_pcie_function.DeviceNumber,
    .function         = m_pcie_device_pcie_function.FunctionNumber,
    .pci_info_address = VID_DID_ADDRESS, // VendorID + DeviceID
    .rlen             = 4,
};

// 获取设备信息（返回 std::optional<std::vector<uint8_t>>，小端序 VID/DID）
auto info = m_imu_obj->get_info_from_imu(true, req);
if (info && info->size() >= 4) {
    uint16_t device_id = (static_cast<uint16_t>((*info)[3]) << 8) | (*info)[2];
    uint16_t vendor_id = (static_cast<uint16_t>((*info)[1]) << 8) | (*info)[0];
    ilog("VID=0x${vid:04x}, DID=0x${did:04x}", ("vid", vendor_id)("did", device_id));
}

// 设备驱动描述结构
struct device_driver {
    const char*        device_name; // 设备名称（如 "PCIeNicCard"）
    const driver_ctor  ctor;        // 创建函数
    const driver_init  init;        // 初始化函数
    const driver_start start;       // 启动函数
    const driver_stop  stop;        // 停止函数
    driver_dump        dump = nullptr; // 可选：设备状态转储
};
typedef struct device_driver device_driver_t;

// 驱动SO导出的注册函数：返回驱动数组及其数量
status_t register_device_driver(device_driver_t** device_driver, uint8_t* count);

// gen/include/device_tree/interface/MyDevice.h
#ifndef GEN_MY_DEVICE_INTERFACE_H
#define GEN_MY_DEVICE_INTERFACE_H

#include <device_tree/base.h>

namespace dev::gen {

class MC_API MyDevice : public mc::engine::interface<MyDevice> {
public:
    MC_INTERFACE("bmc.dev.MyDevice")

    // 设备属性定义
    property<std::string> DeviceName;
    property<uint8_t>     DeviceId;
    property<std::string> Version;
    property<bool>        IsEnabled;

    // 虚函数接口（如需要）
    virtual bool Initialize();
    virtual bool GetStatus();
    virtual void SetEnabled(bool enabled);
};

} // namespace dev::gen

#endif // GEN_MY_DEVICE_INTERFACE_H

// drivers/internal/my_device/my_device_internal.h
#ifndef MY_DEVICE_INTERNAL_H
#define MY_DEVICE_INTERNAL_H

#include <memory>
#include <vector>
#include <mc/dict.h>

class MyDeviceInternal {
public:
    MyDeviceInternal() = default;
    ~MyDeviceInternal() = default;

    bool init(const mc::dict& config);
    bool start();
    bool stop();

    // 硬件操作接口
    bool read_register(uint32_t offset, uint32_t& value);
    bool write_register(uint32_t offset, uint32_t value);
    bool get_device_status();

private:
    std::string m_device_name;
    uint8_t m_device_id;
    bool m_initialized = false;

    // 硬件资源管理
    void* m_hardware_handle = nullptr;
};

#endif // MY_DEVICE_INTERNAL_H

// drivers/internal/my_device/my_device_internal.cpp
#include "my_device_internal.h"
#include <mc/log.h>

bool MyDeviceInternal::init(const mc::dict& config) {
    try {
        m_device_name = config["DeviceName"].as<std::string>();
        m_device_id = config["DeviceId"].as<uint8_t>();

        // 硬件初始化逻辑
        // m_hardware_handle = open_hardware_device(m_device_id);

        m_initialized = true;
        ilog("MyDevice initialized: ${name} (ID: ${id})",
             ("name", m_device_name)("id", m_device_id));
        return true;
    } catch (const std::exception& e) {
        elog("Failed to initialize MyDevice: ${error}", ("error", e.what()));
        return false;
    }
}

bool MyDeviceInternal::read_register(uint32_t offset, uint32_t& value) {
    if (!m_initialized) {
        elog("Device not initialized");
        return false;
    }

    // 实现具体的寄存器读取逻辑
    // value = hardware_read(m_hardware_handle, offset);

    return true;
}

// drivers/my_device/interface/i_my_device.h
#ifndef I_MY_DEVICE_H
#define I_MY_DEVICE_H

#include <device_tree/interface/MyDevice.h>
#include "../internal/my_device_internal.h"

namespace dev {

// MyDevice 默认值常量
constexpr uint8_t     MY_DEVICE_DEFAULT_ID      = 0;
constexpr bool        MY_DEVICE_DEFAULT_ENABLED = false;
constexpr const char* MY_DEVICE_DEFAULT_VERSION = "1.0";

class IMyDevice : public mc::engine::interface<IMyDevice, gen::MyDevice> {
public:
    IMyDevice() {
        // 使用默认值初始化成员变量
        DeviceId  = MY_DEVICE_DEFAULT_ID;
        IsEnabled = MY_DEVICE_DEFAULT_ENABLED;
        Version   = MY_DEVICE_DEFAULT_VERSION;
    }
    ~IMyDevice() = default;

    // 实现设备树接口的虚函数
    bool Initialize() override;
    bool GetStatus() override;
    void SetEnabled(bool enabled) override;

    // 从variant中加载配置到基类属性
    void from_variant(mc::mutable_dict& csr_object);

private:
    std::unique_ptr<MyDeviceInternal> m_internal;
};

} // namespace dev

#endif // I_MY_DEVICE_H

// drivers/my_device/my_device.h
#ifndef MY_DEVICE_H
#define MY_DEVICE_H

#include <mc/engine.h>
#include "interface/i_my_device.h"

namespace dev {

class MyDevice : public mc::engine::object<MyDevice> {
public:
    MC_OBJECT(MyDevice, "MyDevice", "/bmc/dev/MyDevice/${DeviceName}", (IMyDevice))

    MyDevice() = default;
    ~MyDevice() = default;

    // 生命周期管理
    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);
    bool start();
    bool stop();

    // 设备接口实例
    IMyDevice i_my_device;

private:
    bool m_started = false;
};

} // namespace dev

MC_REFLECT(dev::MyDevice, ((i_my_device, "bmc.dev.MyDevice")))

#endif // MY_DEVICE_H

// drivers/my_device/my_device_abi.cpp
#include <devmon/driver_abi.h>
#include <mc/log.h>
#include "my_device.h"

using namespace dev;

extern "C" {

driver_handle_t create_my_device(void* service, const char* name) {
    try {
        if (service == nullptr || name == nullptr) {
            elog("Error creating MyDevice: invalid parameters");
            return nullptr;
        }

        MyDevice* device = new MyDevice();
        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 MyDevice: ${error}", ("error", e.what()));
        return nullptr;
    }
}

status_t init_my_device(driver_handle_t device, void* csr_object, void* connector) {
    if (device == nullptr || csr_object == nullptr || connector == nullptr) {
        elog("Error initializing MyDevice: invalid parameters");
        return STATUS_ERROR;
    }

    MyDevice* device_object = static_cast<MyDevice*>(device);
    mc::mutable_dict* csr_object_ptr = static_cast<mc::mutable_dict*>(csr_object);
    mc::dict* 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_my_device(driver_handle_t device) {
    if (device == nullptr) {
        elog("Error starting MyDevice: device is null");
        return STATUS_ERROR;
    }
    MyDevice* device_object = static_cast<MyDevice*>(device);
    bool ret = device_object->start();
    return ret ? STATUS_OK : STATUS_ERROR;
}

status_t stop_my_device(driver_handle_t device) {
    if (device == nullptr) {
        elog("Error stopping MyDevice: device is null");
        return STATUS_ERROR;
    }
    MyDevice* device_object = static_cast<MyDevice*>(device);
    bool ret = device_object->stop();
    return ret ? STATUS_OK : STATUS_ERROR;
}

// 设备驱动信息
device_driver_t my_device_driver = {
    .device_name = "MyDevice",
    .ctor = create_my_device,
    .init = init_my_device,
    .start = start_my_device,
    .stop = stop_my_device
};

} // extern "C"

// 华为海思Hi182x网卡示例
class hi182x_card : public mc::engine::object<hi182x_card> {
public:
    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))

    // === 接口对象组合 ===
    NetworkAdapter_Oem           m_network_adapter_oem;           // 网络适配器OEM扩展
    PCIeDevice                   m_pcie_device;                   // PCIe设备信息
    PCIeDevice_PCIeFunction      m_pcie_device_pcie_function;     // PCIe功能信息
    PCIeDevice_Oem               m_pcie_device_oem;               // PCIe设备OEM扩展
    PCIeDevice_Status            m_pcie_device_status;            // PCIe设备状态
    PCIeCard                     m_pcie_card;                     // PCIe卡片信息
    PCIeCard_Oem                 m_pcie_card_oem;                 // PCIe卡片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;                           // FRU信息
    uint8_t                      m_system_id;                     // 系统ID

    // === 生命周期管理 ===
    bool start();
    bool stop();
    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);

private:
    // === 子设备管理 ===
    std::vector<hi182x_port*> m_network_ports;      // 网络端口集合

    // === 协议支持 ===
    ref_chip_ptr          m_ref_chip;               // 参考芯片对象
    smbus_obj_ptr         m_smbus_obj;              // SMBUS通信
    imu_ptr               m_imu_obj;                // IMU设备管理
    ncsi_over_mctp_hw_ptr m_ncsi_over_mctp_huawei;  // 华为NCSI over MCTP协议
    mc::milliseconds      m_interval       = mc::milliseconds(5000); // NCSI更新间隔5s
    mc::milliseconds      m_smbus_interval = mc::milliseconds(5000); // SMBUS更新间隔5s
    mc::shared_ptr<mctp>  m_mctp_object;            // MCTP底层协议

    // === 协议生命周期管理 ===
    void init_network_ports();     // 初始化网络端口
    bool start_ncsi_protocol();    // 启动NCSI协议
    bool start_smbus_protocol();   // 启动SMBUS协议
    bool init_imu_protocol();      // 初始化IMU协议
    bool start_protocol();         // 启动NCSI over MCTP协议
};

// 英诺硅AWM-M11P GPU卡示例
class awm_m11p_card : public mc::engine::object<awm_m11p_card> {
public:
    MC_OBJECT(awm_m11p_card, "PCIeGpuCard",
              "/bmc/dev/Systems/1/PCIeGpuCard/${object_name}",
              (PCIeDevice)(PCIeDevice_Oem)(PCIeDevice_Status)(PCIeDevice_PCIeFunction)(PCIeCard)(PCIeCard_Oem))

    PCIeDevice              m_pcie_device;              // PCIe设备信息
    PCIeDevice_Oem          m_pcie_device_oem;          // PCIe设备OEM信息
    PCIeDevice_Status       m_pcie_device_status;       // PCIe设备状态
    PCIeDevice_PCIeFunction m_pcie_device_pcie_function; // PCIe功能信息
    PCIeCard                m_pcie_card;                // PCIe卡片信息
    PCIeCard_Oem            m_pcie_card_oem;            // PCIe卡片OEM信息
    uint8_t                 SystemId;                   // 系统ID

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

class hi182x_card : public mc::engine::object<hi182x_card> {
private:
    // === 协议对象管理 ===
    ncsi_over_mctp_hw_ptr m_ncsi_over_mctp_huawei;  // 华为NCSI over MCTP
    imu_ptr               m_imu_obj;                // IMU设备管理协议
    smbus_obj_ptr         m_smbus_obj;              // SMBUS系统管理总线
    mc::shared_ptr<mctp>  m_mctp_object;            // MCTP底层协议对象

    // === 定时任务管理 ===
    mc::milliseconds m_interval       = mc::milliseconds(5000);  // NCSI更新间隔
    mc::milliseconds m_smbus_interval = mc::milliseconds(5000);  // SMBUS更新间隔

    // === 协议启动和管理 ===
    // 各协议独立启动，start() 中按序调用：
    //   start_protocol();        // 启动 NCSI over MCTP
    //   start_smbus_protocol();  // 启动 SMBUS
    //   init_imu_protocol();     // 初始化 IMU
    bool start_protocol() {
        return start_ncsi_protocol();
    }

    bool start_ncsi_protocol() {
        // 校验BDF已初始化
        if (m_pcie_device_pcie_function.BusNumber == 0 &&
            m_pcie_device_pcie_function.DeviceNumber == 0 &&
            m_pcie_device_pcie_function.FunctionNumber == 0) {
            elog("PCIe device BDF not initialized");
            return false;
        }

        // 1. 计算物理地址并创建 MCTP 对象
        uint16_t phy_addr =
            mctp::init_phy_addr(m_pcie_device_pcie_function.BusNumber,
                                m_pcie_device_pcie_function.DeviceNumber,
                                m_pcie_device_pcie_function.FunctionNumber);
        m_mctp_object = mc::make_shared<mctp>(this, phy_addr,
                                              MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NCSI, "");

        // 2. 在端点就绪回调中创建 NCSI over MCTP 实例并绑定各接口任务
        auto ncsi_update_task = [this]() {
            m_ncsi_over_mctp_huawei = std::make_shared<ncsi_over_mctp_huawei>(m_mctp_object);
            for (auto& port : m_network_ports) {
                port->start_ncsi_update_task(m_ncsi_over_mctp_huawei, m_interval);
                port->enable_lldp_over_mctp();   // 开启 lldp_over_mctp 透传
            }
            m_network_adapter.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei, mc::milliseconds(120000));
            m_network_adapter_fault_status.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei, m_interval);
            m_pcie_device_bandwidth.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei, mc::milliseconds(180000));
            m_pcie_device_pcie_function.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei,
                                                                      mc::milliseconds(120000));
            m_cooling.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei, m_interval);
            m_network_adapter_log_collection.init_ncsi_endpoint(m_ncsi_over_mctp_huawei);
        };
        m_mctp_object->create_transport_and_endpoint(std::string(get_object_name()), ncsi_update_task);
        return true;
    }
};

// 华为海思 - 支持NCSI+IMU+SMBUS
class hi182x_card {
    ncsi_over_mctp_hw_ptr m_ncsi_over_mctp_huawei; // 华为专用NCSI
    imu_ptr               m_imu_obj;                // IMU协议
    smbus_obj_ptr         m_smbus_obj;              // SMBUS协议
};

// 网迅 - 支持NCSI+IMU，附加四元组更新
class rp1000_card {
    ncsi_over_mctp_wx_ptr          m_ncsi_over_mctp_wx;          // 网迅专用NCSI over MCTP
    imu_ptr                        m_imu_obj;                    // IMU协议
    mc::shared_ptr<mctp>           m_mctp_object        = nullptr; // MCTP底层协议
    mc::milliseconds               m_interval           = mc::milliseconds(5000);   // NCSI更新间隔5s
    mc::milliseconds               m_quadruple_interval = mc::milliseconds(10000);  // 四元组更新间隔10s
    mc::shared_ptr<mc::timer>      m_quadruple_timer;           // 四元组更新定时器
    bool                           m_first_quadruple_update;    // 是否首次四元组更新
};

// 英诺硅GPU - 简化协议支持
class awm_m11p_card {
    // GPU卡通常协议需求较简单，主要依赖PCIe标准接口
};

void hi182x_card::init_network_ports() {
    auto objects = get_children();  // 获取所有子对象
    if (objects.empty()) {
        elog("Error: No network ports found");
        return;
    }

    for (auto& object : objects) {
        auto object_name = object->get_name();

        // 通过对象名前缀识别设备类型
        if (object_name.substr(0, object_name.find_first_of("_")) == "NicPort") {
            // 使用 dynamic_cast 并校验空指针，避免向下转换失败
            auto* port = dynamic_cast<hi182x_port*>(object.get());
            if (port == nullptr) {
                elog("hi182x_card child ${name} is not hi182x_port, skip", ("name", object_name));
                continue;
            }
            ilog("hi182x_card init network port ${name}", ("name", object_name));
            m_network_ports.push_back(port);
        }
        // 可以添加其他子设备类型的识别
        else if (object_name.find("OpticalTransceiver") != std::string::npos) {
            // 光模块设备处理
        }
    }
}

bool hi182x_card::start() {
    // 1. 初始化子设备
    init_network_ports();

    // 2. 启动所有子设备
    for (auto& port : m_network_ports) {
        port->start();
        if (port->m_optical_module) {
            port->m_optical_module->m_optical_module_status.set_network_adapter_oem(&m_network_adapter_oem);
            port->m_optical_module->m_optical_module_temperature_celsius.set_network_adapter_oem(
                &m_network_adapter_oem);
        }
    }

    // 3. 建立主接口间的交叉引用
    m_cooling.set_network_adapter_oem(&m_network_adapter_oem);
    m_network_adapter_fault_status.set_network_adapter_oem(&m_network_adapter_oem);
    m_network_adapter_oem.set_network_adapter(&m_network_adapter);
    m_network_adapter.set_network_adapter_oem(&m_network_adapter_oem);

    // 4. 各协议独立启动
    start_protocol();       // 启动 NCSI over MCTP
    start_smbus_protocol(); // 启动 SMBUS
    setup_vdpci_lldp_listener();
    init_imu_protocol();    // 初始化 IMU

    // 5. 注册事件回调
    m_network_adapter_oem.register_os_reset_callback([this]() {
        this->handle_os_reset();
    });
    m_network_adapter_oem.register_os_off_callback([this]() {
        this->handle_os_off();
    });

    return true;
}

bool hi182x_card::stop() {
    // 1. 停止各协议更新任务
    stop_ncsi_update_task();
    m_network_adapter_log_collection.clean_ncsi_endpoint();
    for (auto& port : m_network_ports) {
        if (port != nullptr) {
            port->stop_ncsi_update_task();
        }
    }
    if (m_smbus_obj) {
        stop_smbus_update_task();
        m_network_adapter_log_collection.clean_smbus_obj();
        m_network_adapter_oem.clean_smbus_obj();
        for (auto& port : m_network_ports) {
            if (port != nullptr) {
                port->stop_smbus_update_task();
            }
        }
    }
    for (auto& port : m_network_ports) {
        if (port != nullptr) {
            port->stop_lldp_clear_timer();
        }
    }

    // 2. 注销回调并断开交叉引用
    m_network_adapter_oem.unregister_os_reset_callback();
    m_network_adapter_oem.unregister_os_off_callback();
    m_network_adapter_oem.unregister_eeprom_wp_callback();
    m_network_adapter_oem.set_network_adapter(nullptr);
    m_network_adapter.set_network_adapter_oem(nullptr);
    m_cooling.set_network_adapter_oem(nullptr);
    m_network_adapter_fault_status.set_network_adapter_oem(nullptr);

    return true;
}

// PCIe网卡ABI实现示例
extern "C" {

// === 主板卡设备ABI ===
driver_handle_t create_hi182x_card(void* service, const char* name) {
    try {
        if (service == nullptr || name == nullptr) {
            return nullptr;
        }
        hi182x_card* device = new hi182x_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 hi182x PCIeNicCard: ${error}", ("error", e.what()));
        return nullptr;
    }
}

status_t init_hi182x_card(driver_handle_t device, void* csr_object, void* connector) {
    if (device == nullptr || csr_object == nullptr || connector == nullptr) {
        elog("Error initializing hi182x PCIeNicCard: device is null");
        return STATUS_ERROR;
    }
    hi182x_card*      device_object  = static_cast<hi182x_card*>(device);
    mc::mutable_dict* csr_object_ptr = static_cast<mc::mutable_dict*>(csr_object);
    mc::dict*         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_hi182x_card(driver_handle_t device) {
    if (device == nullptr) {
        elog("Error starting hi182x PCIeNicCard: device is null");
        return STATUS_ERROR;
    }
    hi182x_card* device_object = static_cast<hi182x_card*>(device);
    device_object->start();
    return STATUS_OK;
}

status_t stop_hi182x_card(driver_handle_t device) {
    if (device == nullptr) {
        elog("Error stopping hi182x PCIeNicCard: device is null");
        return STATUS_ERROR;
    }
    hi182x_card* device_object = static_cast<hi182x_card*>(device);
    device_object->stop();
    return STATUS_OK;
}

// === 网络端口子设备ABI ===
driver_handle_t create_hi182x_port(void* service, const char* name) {
    try {
        if (service == nullptr || name == nullptr) {
            return nullptr;
        }
        hi182x_port* device = new hi182x_port();
        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 hi182x NicPort: ${error}", ("error", e.what()));
        return nullptr;
    }
}

// === 光模块子设备ABI ===
driver_handle_t create_hi182x_optical_module(void* service, const char* name) {
    try {
        if (service == nullptr || name == nullptr) {
            return nullptr;
        }
        hi182x_optical_module* device = new hi182x_optical_module();
        device->set_object_name(name);
        device->set_service(static_cast<mc::engine::service*>(service));
        return (void*)device;
    } catch (const std::exception& e) {
        elog("Error creating hi182x OpticalTransceiver: ${error}", ("error", e.what()));
        return nullptr;
    }
}

// === 设备驱动注册表 ===
device_driver_t hi182x_card_device_driver = {
    .device_name = "PCIeNicCard",
    .ctor        = create_hi182x_card,
    .init        = init_hi182x_card,
    .start       = start_hi182x_card,
    .stop        = stop_hi182x_card
};

device_driver_t hi182x_port_device_driver = {
    .device_name = "NicPort",
    .ctor        = create_hi182x_port,
    .init        = init_hi182x_port,
    .start       = start_hi182x_port,
    .stop        = stop_hi182x_port
};

device_driver_t hi182x_optical_module_device_driver = {
    .device_name = "OpticalTransceiver",
    .ctor        = create_hi182x_optical_module,
    .init        = init_hi182x_optical_module,
    .start       = start_hi182x_optical_module,
    .stop        = stop_hi182x_optical_module
};

// === 驱动导出 ===
device_driver_t hi182x_device_driver[] = {
    hi182x_card_device_driver,
    hi182x_port_device_driver,
    hi182x_optical_module_device_driver
};

status_t register_device_driver(device_driver_t** device_driver, uint8_t* count) {
    *device_driver = hi182x_device_driver;
    *count = sizeof(hi182x_device_driver) / sizeof(hi182x_device_driver[0]);
    return STATUS_OK;
}

} // extern "C"

class hi182x_card : public mc::engine::object<hi182x_card> {
private:
    // === 智能指针管理协议对象 ===
    mc::shared_ptr<mctp>          m_mctp_object;               // 框架智能指针管理MCTP
    std::shared_ptr<ncsi_over_mctp_huawei> m_ncsi_over_mctp_huawei; // 自动管理生命周期
    std::shared_ptr<imu>          m_imu_obj;                   // 支持多对象共享
    mc::shared_ptr<smbus>         m_smbus_obj;                 // 框架智能指针
    mc::shared_ptr<mc::timer>     m_quadruple_timer;           // 定时器使用框架智能指针

public:
    ~hi182x_card() {
        // === 取消回调注册，避免悬空指针 ===
        m_network_adapter_oem.unregister_os_reset_callback();
        m_network_adapter_oem.unregister_os_off_callback();
    }
};

bool hi182x_card::start_ncsi_protocol() {
    // === 资源获取即初始化(RAII) ===
    // MCTP对象由框架智能指针管理，端点就绪后创建 NCSI over MCTP 实例
    if (m_mctp_object == nullptr) {
        elog("mctp object is null");
        return false;
    }

    auto ncsi_update_task = [this]() {
        try {
            // 创建 NCSI over MCTP 实例（构造参数为 MCTP 智能指针）
            m_ncsi_over_mctp_huawei = std::make_shared<ncsi_over_mctp_huawei>(m_mctp_object);

            // === 批量操作的事务性处理 ===
            for (auto& port : m_network_ports) {
                port->start_ncsi_update_task(m_ncsi_over_mctp_huawei, m_interval);
            }

            // === 各接口绑定独立的更新任务 ===
            m_network_adapter.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei,
                                                            mc::milliseconds(120000));
            m_network_adapter_fault_status.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei, m_interval);
            m_pcie_device_bandwidth.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei,
                                                                  mc::milliseconds(180000));
            m_pcie_device_pcie_function.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei,
                                                                      mc::milliseconds(120000));
            m_cooling.start_ncsi_update_task_huawei(m_ncsi_over_mctp_huawei, m_interval);
            m_network_adapter_log_collection.init_ncsi_endpoint(m_ncsi_over_mctp_huawei);
        } catch (const std::exception& e) {
            elog("Exception in start_ncsi_protocol: ${error}", ("error", e.what()));
            // 异常时清理已启动的任务
            stop_ncsi_update_task();
        } catch (...) {
            elog("Unknown exception in start_ncsi_protocol");
            stop_ncsi_update_task();
        }
    };

    // 创建传输层和端点，就绪后回调 ncsi_update_task
    m_mctp_object->create_transport_and_endpoint(std::string(get_object_name()), ncsi_update_task);
    return true;
}

// === 基础接口统一，实现差异化 ===

// 1. 协议差异 - 继承统一基类，实现厂商专用协议
class ncsi_over_mctp_huawei : public ncsi_over_mctp_base { /* 华为实现 */ };
class ncsi_over_mctp_wx : public ncsi_over_mctp_base { /* 网迅实现 */ };

// 2. 功能差异 - 通过接口组合支持不同功能集
class hi182x_card {
    NetworkAdapter_FaultStatus   m_fault_status;    // 华为特有
    NetworkAdapter_LogCollection m_log_collection;  // 华为特有
};

class wx_card {
    // 网迅不支持故障状态和日志收集接口
    mc::shared_ptr<mc::timer> m_quadruple_timer;  // 网迅特有四元组更新定时器
};

// 3. 定时任务差异 - 不同厂商使用不同更新间隔
class hi182x_card {
    mc::milliseconds m_interval       = mc::milliseconds(5000);  // 5秒NCSI更新
    mc::milliseconds m_smbus_interval = mc::milliseconds(5000);  // 5秒SMBUS更新
};

class wx_card {
    mc::milliseconds m_interval = mc::milliseconds(5000);         // 5秒NCSI更新
    mc::milliseconds m_quadruple_interval = mc::milliseconds(10000); // 10秒四元组更新
};

class hi182x_card {
    bool start() {
        ilog("Starting hi182x_card: ${name}", ("name", get_object_name()));

        // === 关键步骤日志 ===
        ilog("Initializing network ports...");
        init_network_ports();
        ilog("Found ${count} network ports", ("count", m_network_ports.size()));

        // === 协议启动日志 ===
        ilog("Starting NCSI protocol...");
        if (!start_ncsi_protocol()) {
            elog("Failed to start NCSI protocol");
            return false;
        }
        ilog("NCSI protocol started successfully");

        // === 性能监控日志 ===
        dlog("hi182x_card started in ${time}ms", ("time", start_time));
        return true;
    }

    void update_device_status() {
        try {
            // === 调试级详细日志 ===
            dlog("Updating device status via NCSI...");

            // NCSI over MCTP 实例未创建时记录警告
            if (m_ncsi_over_mctp_huawei == nullptr) {
                wlog("NCSI over MCTP instance is null, skip update");
                return;
            }
            dlog("Device status updated: ${name}, BDF=${bus}:${dev}:${func}",
                 ("name", m_pcie_device.DeviceName.get_value().as<std::string>()),
                 ("bus", m_pcie_device_pcie_function.BusNumber),
                 ("dev", m_pcie_device_pcie_function.DeviceNumber),
                 ("func", m_pcie_device_pcie_function.FunctionNumber));
        } catch (const std::exception& e) {
            elog("Exception in update_device_status: ${error}", ("error", e.what()));
        }
    }
};

bool start_ncsi_protocol() {
    // 1. 验证PCIe设备BDF已初始化
    if (m_pcie_device_pcie_function.BusNumber == 0 &&
        m_pcie_device_pcie_function.DeviceNumber == 0 &&
        m_pcie_device_pcie_function.FunctionNumber == 0) {
        elog("PCIe device ${name} BDF not initialized",
             ("name", m_pcie_device.DeviceName.get_value().as<std::string>()));
        return false;
    }

    // 2. 检查网络端口子设备是否发现
    if (m_network_ports.empty()) {
        elog("No network ports found, NCSI protocol cannot start");
        return false;
    }

    // 3. 计算物理地址并创建MCTP对象
    uint16_t phy_addr =
        mctp::init_phy_addr(m_pcie_device_pcie_function.BusNumber,
                            m_pcie_device_pcie_function.DeviceNumber,
                            m_pcie_device_pcie_function.FunctionNumber);
    m_mctp_object = mc::make_shared<mctp>(this, phy_addr,
                                          MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NCSI, "");

    // 4. 创建传输层和端点，就绪后回调绑定接口任务
    m_mctp_object->create_transport_and_endpoint(std::string(get_object_name()), ncsi_update_task);
    return true;
}

void init_network_ports() {
    auto objects = get_children();

    // 1. 检查子设备数量
    if (objects.empty()) {
        wlog("No child objects found, expected network ports");
        return;
    }

    // 2. 验证子设备类型
    for (auto& object : objects) {
        if (!dynamic_cast<hi182x_port*>(object.get())) {
            wlog("Invalid child object type: ${name}", ("name", object->get_name()));
            continue;
        }
        // 添加到管理列表
    }

    // 3. 验证最终结果
    if (m_network_ports.empty()) {
        elog("No valid network ports found");
    }
}

// tests/my_device_test.cpp
#include <gtest/gtest.h>
#include "../drivers/my_device/my_device.h"

class MyDeviceTest : public ::testing::Test {
protected:
    void SetUp() override {
        m_device = std::make_unique<dev::MyDevice>();
    }

    void TearDown() override {
        if (m_device) {
            m_device->stop();
        }
    }

    std::unique_ptr<dev::MyDevice> m_device;
};

TEST_F(MyDeviceTest, InitializationTest) {
    mc::mutable_dict config;
    config["DeviceName"] = std::string("TestDevice");
    config["DeviceId"] = uint8_t(1);

    mc::dict connector;
    EXPECT_TRUE(m_device->init(config, connector));
}

// tests/integration/my_device_integration_test.cpp
class MyDeviceIntegrationTest : public ::testing::Test {
protected:
    void SetUp() override {
        m_service = std::make_unique<mc::engine::service>();
    }

    std::unique_ptr<mc::engine::service> m_service;
};

TEST_F(MyDeviceIntegrationTest, ABI_Test) {
    driver_handle_t handle = create_my_device(m_service.get(), "TestDevice");
    EXPECT_NE(handle, nullptr);

    mc::mutable_dict config;
    config["DeviceName"] = std::string("TestDevice");
    mc::dict connector;

    EXPECT_EQ(init_my_device(handle, &config, &connector), STATUS_OK);
    EXPECT_EQ(start_my_device(handle), STATUS_OK);
    EXPECT_EQ(stop_my_device(handle), STATUS_OK);
}

class PerformantDevice {
private:
    // 使用对象池减少内存分配
    std::vector<std::unique_ptr<DataBuffer>> m_buffer_pool;
    std::mutex m_pool_mutex;

    static constexpr size_t BUFFER_POOL_SIZE = 64;
    static constexpr size_t BUFFER_SIZE = 4096;

public:
    void init_buffer_pool() {
        m_buffer_pool.reserve(BUFFER_POOL_SIZE);
        for (size_t i = 0; i < BUFFER_POOL_SIZE; ++i) {
            m_buffer_pool.push_back(
                std::make_unique<DataBuffer>(BUFFER_SIZE));
        }
    }

    std::unique_ptr<DataBuffer> get_buffer() {
        std::lock_guard<std::mutex> lock(m_pool_mutex);
        if (!m_buffer_pool.empty()) {
            auto buffer = std::move(m_buffer_pool.back());
            m_buffer_pool.pop_back();
            return buffer;
        }
        return std::make_unique<DataBuffer>(BUFFER_SIZE);
    }
};

class AsyncDevice {
private:
    // 使用 mc::runtime 线程池执行异步任务
    std::shared_ptr<mc::runtime::thread_pool>        m_thread_pool;
    mc::runtime::thread_pool::executor_type          m_executor;

public:
    AsyncDevice()
        : m_thread_pool(std::make_shared<mc::runtime::thread_pool>(4, "device_pool")),
          m_executor(m_thread_pool->get_executor())
    {}

    // 提交异步任务（post 不等待返回）
    void submit_async_task(std::function<void()> task) {
        m_executor.post(std::move(task));
    }

    // 分发任务（dispatch 可在调用线程直接执行）
    void dispatch_async_task(std::function<void()> task) {
        m_executor.dispatch(std::move(task));
    }

    // 延迟执行（defer 延迟到当前任务结束后执行）
    void defer_async_task(std::function<void()> task) {
        m_executor.defer(std::move(task));
    }
};

enum class DeviceError {
    SUCCESS = 0,
    INIT_FAILED,
    HARDWARE_ERROR,
    PROTOCOL_ERROR,
    TIMEOUT_ERROR,
    INVALID_CONFIG
};

class ErrorHandler {
public:
    static bool handle_error(DeviceError error, const std::string& context) {
        switch (error) {
            case DeviceError::INIT_FAILED:
                elog("Device initialization failed in ${context}", ("context", context));
                return retry_initialization();

            case DeviceError::HARDWARE_ERROR:
                elog("Hardware error detected in ${context}", ("context", context));
                return perform_hardware_reset();

            default:
                elog("Unknown error in ${context}", ("context", context));
                return false;
        }
    }
};

class DebugHelper {
public:
    // 设备状态转储
    static void dump_device_state(const MyDevice& device) {
        ilog("=== Device State Dump ===");
        ilog("Name: ${name}", ("name", device.i_my_device.DeviceName.value()));
        ilog("ID: ${id}", ("id", device.i_my_device.DeviceId.value()));
        ilog("========================");
    }

    // 性能监控
    class PerformanceMonitor {
    private:
        std::chrono::high_resolution_clock::time_point m_start;
        std::string m_operation;

    public:
        PerformanceMonitor(const std::string& operation)
            : m_operation(operation), m_start(std::chrono::high_resolution_clock::now()) {}

        ~PerformanceMonitor() {
            auto end = std::chrono::high_resolution_clock::now();
            auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - m_start);
            dlog("${operation} took ${duration} microseconds",
                 ("operation", m_operation)("duration", duration.count()));
        }
    };
};

class ResourceManager {
private:
    struct Resource {
        void* handle;
        std::function<void(void*)> deleter;

        ~Resource() {
            if (handle && deleter) {
                deleter(handle);
            }
        }
    };

    std::vector<std::unique_ptr<Resource>> m_resources;
};

class ThreadSafeDevice {
private:
    mutable std::shared_mutex m_device_mutex;
    DeviceState m_state;

public:
    // 读操作使用共享锁
    DeviceState get_state() const {
        std::shared_lock<std::shared_mutex> lock(m_device_mutex);
        return m_state;
    }

    // 写操作使用独占锁
    void set_state(const DeviceState& state) {
        std::unique_lock<std::shared_mutex> lock(m_device_mutex);
        m_state = state;
    }
};