Root Complex (RC, 集成在CPU/芯片组内)
  ├── Endpoint (网卡)
  ├── Switch
    ├── Endpoint (NVMe SSD)
    └── Endpoint (FPGA加速卡)
  └── Endpoint (GPU)

// include/linux/pci.h（简化）
struct pci_driver {
    const char *name;           // 驱动名，/sys/bus/pci/drivers/下可。    const struct pci_device_id *id_table;  // 设备匹配置    int  (*probe)(struct pci_dev *pdev,
                  const struct pci_device_id *ent);  // 设备发现时调试    void (*remove)(struct pci_dev *pdev);             // 设备移除时调试    int  (*suspend)(struct pci_dev *pdev, pm_message_t state);
    int  (*resume)(struct pci_dev *pdev);
    void (*shutdown)(struct pci_dev *pdev);
    struct device_driver driver;  // 内嵌device_driver
};

// 注册PCIe驱动
module_pci_driver(my_pci_driver);

// 等价于：
// static int __init my_init(void) { return pci_register_driver(&my_pci_driver); }
// module_init(my_init);
// static void __exit my_exit(void) { pci_unregister_driver(&my_pci_driver); }
// module_exit(my_exit);

// include/linux/mod_devicetable.h
struct pci_device_id {
    __u32 vendor;       // Vendor ID，PCI_ANY_ID表示通配
    __u32 device;       // Device ID
    __u32 subvendor;    // Subsystem Vendor ID
    __u32 subdevice;    // Subsystem Device ID
    __u32 class;        // Class Code
    __u32 class_mask;   // Class匹配掩码
    kernel_ulong_t driver_data;  // 驱动私有数据
};

// 匹配示例
static const struct pci_device_id my_pci_ids[] = {
    // 精确匹配：某厂商某设。    { PCI_DEVICE(0x10ee, 0x8030) },
    // 匹配某厂商所有设。    { PCI_DEVICE(0x10ee, PCI_ANY_ID) },
    // 匹配某类设备（网络控制器。    { PCI_DEVICE_CLASS(PCI_CLASS_NETWORK_ETHERNET, 0xffff00) },
    // 子系统精确匹。    { PCI_DEVICE_SUB(0x10ee, 0x8030, 0x10ee, 0x0001) },
    { 0, }  // 结尾哨兵
};
MODULE_DEVICE_TABLE(pci, my_pci_ids);

// include/linux/pci.h（关键字段）
struct pci_dev {
    struct device dev;          // 内嵌device，统一设备模型
    u16 vendor;                 // Vendor ID
    u16 device;                 // Device ID
    u16 subsystem_vendor;       // Subsystem Vendor ID
    u16 subsystem_device;       // Subsystem Device ID
    u8  hdr_type;               // Header Type
    u8  irq;                    // 中断号（INTx。    struct resource resource[DEVICE_COUNT_RESOURCE];  // BAR资源
    // ...
};

// my_pcie_drv.c - 简单PCIe驱动框架（Linux 6.8。#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/io.h>

#define DRV_NAME "my_pcie_drv"

/* 设备ID匹配置*/
static const struct pci_device_id my_pci_ids[] = {
    { PCI_DEVICE(0x1234, 0x5678) },  // 替换为实际VID/DID
    { 0, }
};
MODULE_DEVICE_TABLE(pci, my_pci_ids);

/* 设备私有数据 */
struct my_pcie_dev {
    struct pci_dev *pdev;
    void __iomem *hw_regs;      // MMIO映射地址
    dma_addr_t dma_handle;      // DMA缓冲区总线地址
    void *dma_buf;              // DMA缓冲区虚拟地址
    size_t dma_size;            // DMA缓冲区大。};

/* 中断处理函数 */
static irqreturn_t my_pcie_irq_handler(int irq, void *dev_id)
{
    struct my_pcie_dev *mydev = dev_id;
    u32 status;

    /* 读中断状态寄存器 */
    status = readl(mydev->hw_regs + 0x04);
    if (!status)
        return IRQ_NONE;

    /* 清中*/
    writel(status, mydev->hw_regs + 0x08);

    dev_info(&mydev->pdev->dev, "irq: status=0x%x\n", status);
    return IRQ_HANDLED;
}

/* probe：设备发现时调用 */
static int my_pcie_probe(struct pci_dev *pdev,
                         const struct pci_device_id *ent)
{
    struct my_pcie_dev *mydev;
    int ret;

    dev_info(&pdev->dev, "probe: found device %04x:%04x\n",
             pdev->vendor, pdev->device);

    /* 1. 分配私有数据 */
    mydev = devm_kzalloc(&pdev->dev, sizeof(*mydev), GFP_KERNEL);
    if (!mydev)
        return -ENOMEM;
    mydev->pdev = pdev;
    pci_set_drvdata(pdev, mydev);

    /* 2. 启用PCIe设备 */
    ret = pcim_enable_device(pdev);
    if (ret) {
        dev_err(&pdev->dev, "pcim_enable_device failed: %d\n", ret);
        return ret;
    }

    /* 3. 请求MMIO区域 */
    ret = pcim_iomap_regions(pdev, BIT(0), DRV_NAME);
    if (ret) {
        dev_err(&pdev->dev, "pcim_iomap_regions failed: %d\n", ret);
        return ret;
    }

    /* 4. 获取映射地址 */
    mydev->hw_regs = pcim_iomap_table(pdev)[0];
    if (!mydev->hw_regs) {
        dev_err(&pdev->dev, "pcim_iomap_table returned NULL\n");
        return -ENOMEM;
    }

    /* 5. 设置DMA掩码 */
    ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
    if (ret) {
        ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
        if (ret) {
            dev_err(&pdev->dev, "dma_set_mask failed: %d\n", ret);
            return ret;
        }
    }

    /* 6. 请求MSI中断 */
    ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
    if (ret < 0) {
        dev_warn(&pdev->dev, "MSI failed, trying INTx\n");
        ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_INTX);
        if (ret < 0) {
            dev_err(&pdev->dev, "irq alloc failed: %d\n", ret);
            return ret;
        }
    }

    ret = devm_request_irq(&pdev->dev, pci_irq_vector(pdev, 0),
                           my_pcie_irq_handler, IRQF_SHARED,
                           DRV_NAME, mydev);
    if (ret) {
        dev_err(&pdev->dev, "request_irq failed: %d\n", ret);
        return ret;
    }

    /* 7. 启用总线主控（DMA必需*/
    pci_set_master(pdev);

    dev_info(&pdev->dev, "probe: device initialized\n");
    return 0;
}

/* remove：设备移除时调用 */
static void my_pcie_remove(struct pci_dev *pdev)
{
    struct my_pcie_dev *mydev = pci_get_drvdata(pdev);

    /* devm资源自动释放，无需手动free */
    dev_info(&pdev->dev, "remove: device released\n");
}

/* 电源管理（可选） */
static int my_pcie_suspend(struct pci_dev *pdev, pm_message_t state)
{
    pci_save_state(pdev);
    pci_disable_device(pdev);
    return 0;
}

static int my_pcie_resume(struct pci_dev *pdev)
{
    pci_restore_state(pdev);
    return pcim_enable_device(pdev);
}

/* 驱动结构建*/
static struct pci_driver my_pci_driver = {
    .name      = DRV_NAME,
    .id_table  = my_pci_ids,
    .probe     = my_pcie_probe,
    .remove    = my_pcie_remove,
    .suspend   = my_pcie_suspend,
    .resume    = my_pcie_resume,
};

module_pci_driver(my_pci_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("Simple PCIe driver for Linux 6.8");

// 映射整个BAR（老式写法。.8仍可用但不推荐）
void __iomem *pci_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);

// 映射BAR的指定范。void __iomem *pci_iomap_range(struct pci_dev *pdev, int bar,
                               unsigned long offset, unsigned long maxlen);

// 推荐写法：pcim_iomap_regions + pcim_iomap_table
// 一步完成：请求区域 + 映射
int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);

// 获取映射后的虚拟地址。void __iomem * const *pcim_iomap_table(struct pci_dev *pdev);

// 32位读。u32 val = readl(regs + OFFSET);
writel(val, regs + OFFSET);

// 16位读。u16 val = readw(regs + OFFSET);
writew(val, regs + OFFSET);

// 8位读。u8 val = readb(regs + OFFSET);
writeb(val, regs + OFFSET);

// 。。写（设置某一位）
u32 val = readl(regs + CTRL_OFFSET);
val |= BIT(3);          // 设置bit3
val &= ~BIT(7);         // 清除bit7
writel(val, regs + CTRL_OFFSET);

/* 寄存器偏移定*/
#define REG_CTRL    0x00
#define REG_STATUS  0x04
#define REG_DATA    0x08

/* 控制寄存器位定义 */
#define CTRL_START  BIT(0)
#define CTRL_RESET  BIT(1)
#define CTRL_IRQ_EN BIT(4)

static int my_device_init(struct my_pcie_dev *mydev)
{
    void __iomem *regs = mydev->hw_regs;
    u32 status;

    /* 先复位设*/
    writel(CTRL_RESET, regs + REG_CTRL);
    usleep_range(1000, 2000);

    /* 清状态，使能中断，启*/
    writel(0xffffffff, regs + REG_STATUS);  // 。清零
    writel(CTRL_IRQ_EN | CTRL_START, regs + REG_CTRL);

    /* 等待就绪 */
    status = readl(regs + REG_STATUS);
    if (!(status & BIT(0))) {
        dev_err(&mydev->pdev->dev, "device not ready, status=0x%x\n", status);
        return -EIO;
    }

    return 0;
}

// 获取BAR的物理起始地址
resource_size_t pci_resource_start(struct pci_dev *pdev, int bar);

// 获取BAR的大。resource_size_t pci_resource_end(struct pci_dev *pdev, int bar);

// 获取BAR的标志unsigned long pci_resource_flags(struct pci_dev *pdev, int bar);
// IORESOURCE_MEM  - 内存空间
// IORESOURCE_IO   - I/O空间
// IORESOURCE_MEM_64 - 64位内存空。// IORESOURCE_PREFETCH - 可预。
// 判断BAR是否为内存空。if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
    // 这是内存空间BAR
}

/* 请求MSI中断。个向量） */
int nvec = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
if (nvec < 0) {
    dev_err(&pdev->dev, "MSI alloc failed: %d\n", nvec);
    return nvec;
}

/* 请求MSI-X中断（最。个向量） */
int nvec = pci_alloc_irq_vectors(pdev, 1, 8, PCI_IRQ_MSIX);
if (nvec < 0) {
    dev_err(&pdev->dev, "MSI-X alloc failed: %d\n", nvec);
    return nvec;
}
dev_info(&pdev->dev, "got %d MSI-X vectors\n", nvec);

/* 获取中断号并注册 */
int irq = pci_irq_vector(pdev, 0);  // 。个向量的IRQ。ret = devm_request_irq(&pdev->dev, irq, my_handler, 0, DRV_NAME, mydev);

/* 降级策略：先尝试MSI-X，再MSI，最后INTx */
int nvec = pci_alloc_irq_vectors(pdev, 1, 8,
                                  PCI_IRQ_MSIX | PCI_IRQ_MSI | PCI_IRQ_INTX);

#define MAX_MSIX_VECTORS  4

struct my_pcie_dev {
    struct pci_dev *pdev;
    void __iomem *hw_regs;
    int num_vectors;
    /* 每个向量对应一个队*/
    struct my_queue queues[MAX_MSIX_VECTORS];
};

static irqreturn_t my_queue_irq_handler(int irq, void *dev_id)
{
    struct my_queue *q = dev_id;
    u32 status = readl(q->regs + REG_QUEUE_STATUS);

    if (!status)
        return IRQ_NONE;

    writel(status, q->regs + REG_QUEUE_STATUS);  // 清中。    /* 处理队列事件 */
    return IRQ_HANDLED;
}

static int my_setup_msix(struct my_pcie_dev *mydev)
{
    struct pci_dev *pdev = mydev->pdev;
    int i, ret;

    /* 请求MSI-X向量 */
    ret = pci_alloc_irq_vectors(pdev, 1, MAX_MSIX_VECTORS, PCI_IRQ_MSIX);
    if (ret < 0) {
        dev_warn(&pdev->dev, "MSI-X failed (%d), fallback to MSI\n", ret);
        ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
        if (ret < 0)
            return ret;
    }
    mydev->num_vectors = ret;

    /* 为每个向量注册中*/
    for (i = 0; i < mydev->num_vectors; i++) {
        int irq = pci_irq_vector(pdev, i);
        mydev->queues[i].regs = mydev->hw_regs + i * 0x100;
        mydev->queues[i].idx = i;

        ret = devm_request_irq(&pdev->dev, irq, my_queue_irq_handler,
                               0, DRV_NAME, &mydev->queues[i]);
        if (ret) {
            dev_err(&pdev->dev, "request_irq %d failed: %d\n", i, ret);
            return ret;
        }
    }

    dev_info(&pdev->dev, "setup %d irq vectors\n", mydev->num_vectors);
    return 0;
}

/* 设置DMA掩码——告诉内核设备能访问的地址宽度 */
/* 先尝。4位，不行降级32*/
ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
if (ret) {
    ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
    if (ret) {
        dev_err(&pdev->dev, "no usable DMA mask\n");
        return ret;
    }
}

/* 分配一致性DMA缓冲*/
mydev->dma_size = 4096;
mydev->dma_buf = dma_alloc_coherent(&pdev->dev, mydev->dma_size,
                                     &mydev->dma_handle, GFP_KERNEL);
if (!mydev->dma_buf) {
    dev_err(&pdev->dev, "dma_alloc_coherent failed\n");
    return -ENOMEM;
}

dev_info(&pdev->dev, "dma buf: virt=%p bus=%pad size=%zu\n",
         mydev->dma_buf, &mydev->dma_handle, mydev->dma_size);

/* 使用：CPU写数据，设备DMA读取 */
memset(mydev->dma_buf, 0, mydev->dma_size);
/* 告诉设备DMA地址 */
writel(lower_32_bits(mydev->dma_handle), regs + REG_DMA_ADDR_LO);
writel(upper_32_bits(mydev->dma_handle), regs + REG_DMA_ADDR_HI);
writel(mydev->dma_size, regs + REG_DMA_SIZE);
writel(CTRL_DMA_START, regs + REG_CTRL);

/* 释放（remove时） */
dma_free_coherent(&pdev->dev, mydev->dma_size,
                  mydev->dma_buf, mydev->dma_handle);

/* 发送方向：CPU→设*/
/* 1. 分配普通内存*/
void *tx_buf = kmalloc(buf_size, GFP_KERNEL);
/* 2. 填充数据 */
memcpy(tx_buf, data, data_len);
/* 3. 映射 */
dma_addr_t tx_dma = dma_map_single(&pdev->dev, tx_buf, buf_size,
                                    DMA_TO_DEVICE);
if (dma_mapping_error(&pdev->dev, tx_dma)) {
    dev_err(&pdev->dev, "dma_map_single failed\n");
    kfree(tx_buf);
    return -EIO;
}
/* 4. 告诉设备DMA地址，启动传递*/
writel(lower_32_bits(tx_dma), regs + REG_DMA_SRC_LO);
writel(upper_32_bits(tx_dma), regs + REG_DMA_SRC_HI);
writel(data_len, regs + REG_DMA_LEN);
writel(CTRL_DMA_START, regs + REG_CTRL);

/* 5. 传输完成后取消映*/
dma_unmap_single(&pdev->dev, tx_dma, buf_size, DMA_TO_DEVICE);
kfree(tx_buf);

/* 接收方向：设备→CPU */
dma_addr_t rx_dma = dma_map_single(&pdev->dev, rx_buf, buf_size,
                                    DMA_FROM_DEVICE);
if (dma_mapping_error(&pdev->dev, rx_dma))
    return -EIO;

/* 设备写完后，同步缓存 */
dma_unmap_single(&pdev->dev, rx_dma, buf_size, DMA_FROM_DEVICE);
/* 此时rx_buf中的数据对CPU可见 */

/* DMA寄存器偏*/
#define REG_DMA_CTRL     0x100
#define REG_DMA_SRC_LO   0x104
#define REG_DMA_SRC_HI   0x108
#define REG_DMA_DST_LO   0x10C
#define REG_DMA_DST_HI   0x110
#define REG_DMA_LEN      0x114
#define REG_DMA_STATUS   0x118

#define DMA_CTRL_START   BIT(0)
#define DMA_CTRL_DIR     BIT(1)  // 0=设备到内存，1=内存到设。#define DMA_STATUS_DONE  BIT(0)

static int my_dma_transfer(struct my_pcie_dev *mydev,
                           void *buf, size_t len, bool to_device)
{
    void __iomem *regs = mydev->hw_regs;
    dma_addr_t dma_addr;
    u32 ctrl, status;
    int ret;

    /* 映射DMA缓冲*/
    dma_addr = dma_map_single(&mydev->pdev->dev, buf, len,
                               to_device ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
    if (dma_mapping_error(&mydev->pdev->dev, dma_addr)) {
        dev_err(&mydev->pdev->dev, "dma_map_single failed\n");
        return -EIO;
    }

    /* 设置DMA源地址（系统内存） */
    writel(lower_32_bits(dma_addr), regs + REG_DMA_SRC_LO);
    writel(upper_32_bits(dma_addr), regs + REG_DMA_SRC_HI);

    /* 设置传输长度 */
    writel(len, regs + REG_DMA_LEN);

    /* 启动传输 */
    ctrl = DMA_CTRL_START;
    if (to_device)
        ctrl |= DMA_CTRL_DIR;
    writel(ctrl, regs + REG_DMA_CTRL);

    /* 等待完成（简化版，实际应该用中断*/
    ret = readl_poll_timeout(regs + REG_DMA_STATUS, status,
                              status & DMA_STATUS_DONE,
                              10, 100000);  // 10us间隔。00ms超时
    if (ret) {
        dev_err(&mydev->pdev->dev, "DMA timeout\n");
        dma_unmap_single(&mydev->pdev->dev, dma_addr, len,
                         to_device ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
        return -ETIMEDOUT;
    }

    /* 取消映射 */
    dma_unmap_single(&mydev->pdev->dev, dma_addr, len,
                     to_device ? DMA_TO_DEVICE : DMA_FROM_DEVICE);

    return 0;
}

# 列出所有PCIe设备
lspci

# 详细信息。v详细。vv更详细，-vvv最详细。lspci -v -s 03:00.0

# 查看设备树形拓扑
lspci -t

# 只看某类设备（网络控制器。lspci -d ::0200

# 以数字方式显示（VID/DID。lspci -n -s 03:00.0

# 查看DMA地址宽度
lspci -vvv -s 03:00.0 | grep "DevCap"

# 读取Vendor ID
setpci -s 03:00.0 VENDOR_ID.w

# 读取Device ID
setpci -s 03:00.0 DEVICE_ID.w

# 读取Command寄存。setpci -s 03:00.0 COMMAND.w

# 设置Command寄存器（使能内存空间和总线主控制setpci -s 03:00.0 COMMAND=0x0006

# 读取BAR0
setpci -s 03:00.0 BASE_ADDRESS_0.l

# 读取扩展配置空间（偏。x100。setpci -s 03:00.0 0x100.l

# 查看设备目录
ls /sys/bus/pci/devices/0000:03:00.0/

# 查看Vendor/Device ID
cat /sys/bus/pci/devices/0000:03:00.0/vendor
cat /sys/bus/pci/devices/0000:03:00.0/device

# 查看IRQ。cat /sys/bus/pci/devices/0000:03:00.0/irq

# 查看NUMA节点
cat /sys/bus/pci/devices/0000:03:00.0/numa_node

# 查看当前链路速度和宽。cat /sys/bus/pci/devices/0000:03:00.0/current_link_speed
cat /sys/bus/pci/devices/0000:03:00.0/current_link_width

# 手动绑定/解绑驱动
echo "0000:03:00.0" > /sys/bus/pci/drivers/my_pcie_drv/bind
echo "0000:03:00.0" > /sys/bus/pci/drivers/my_pcie_drv/unbind

# 查看资源（BAR地址和大小）
cat /sys/bus/pci/devices/0000:03:00.0/resource

# 查看链路训练状态lspci -vvv -s 03:00.0 | grep "LnkSta"

# 输出示例。# LnKSta: Speed 8GT/s, Width x4, TrErr- Train- SlotClk+ DLActive- BWMgmt- ABWMgmt-
# DLActive- 表示链路未激。
# 查看链路能力
lspci -vvv -s 03:00.0 | grep "LnkCap"

# 强制重新训练（调试用。setpci -s 03:00.0 CAP_EXP+10.w=0x0020  # 设置Retrain Link```

`DLActive`是关键标志——它。说明链路训练成功，设备可以通信。如果一直是0，检查硬件连接、时钟和复位信号。
## 九、常见问题
### Q1：probe不被调用。
驱动加载了但probe没执行，99%是`pci_device_id`匹配失败。
排查步骤。
```bash
# 1. 确认设备的VID/DID
lspci -n -s 03:00.0
# 输出。3:00.0 0200: 10ee:8030 (rev 01)

# 2. 检查驱动id_table是否包含这个VID/DID
modinfo my_pcie_drv.ko | grep alias
# 输出：alias:          pci:v000010EEd00008030sv*sd*bc*sc*i*

# 3. 检查设备是否已被其他驱动绑。ls -l /sys/bus/pci/devices/0000:03:00.0/driver

# 4. 手动解绑旧驱动再绑定新驱动echo "0000:03:00.0" > /sys/bus/pci/drivers/old_driver/unbind
echo "0000:03:00.0" > /sys/bus/pci/drivers/my_pcie_drv/bind

// 1. 检查BAR是否存在
if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
    dev_err(&pdev->dev, "BAR%d is not memory space\n", bar);
}

// 2. 检查设备是否已启用
if (!pci_device_is_present(pdev)) {
    dev_err(&pdev->dev, "device not present\n");
}

// 3. 检查Command寄存器的内存空间使能。u16 cmd;
pci_read_config_word(pdev, PCI_COMMAND, &cmd);
if (!(cmd & PCI_COMMAND_MEMORY)) {
    dev_err(&pdev->dev, "memory space not enabled\n");
}

/* 降级策略 */
int nvec;

/* 先尝试MSI-X */
nvec = pci_alloc_irq_vectors(pdev, 1, 8, PCI_IRQ_MSIX);
if (nvec < 0) {
    /* 降级到MSI */
    nvec = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
    if (nvec < 0) {
        /* 降级到INTx */
        nvec = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_INTX);
        if (nvec < 0) {
            dev_err(&pdev->dev, "all interrupt types failed\n");
            return nvec;
        }
        dev_info(&pdev->dev, "using INTx\n");
    } else {
        dev_info(&pdev->dev, "using MSI\n");
    }
} else {
    dev_info(&pdev->dev, "using %d MSI-X vectors\n", nvec);
}

/* 1. 检查DMA地址是否超出设备可访问范*/
u64 dma_addr = mydev->dma_handle;
dev_info(&pdev->dev, "dma_addr=%pad, mask=%llx\n",
         &dma_addr, pdev->dev.dma_mask);

/* 2. 流式DMA必须同步缓存 */
dma_addr_t map = dma_map_single(dev, buf, len, DMA_FROM_DEVICE);
/* 设备写完后，CPU读之*/
dma_sync_single_for_cpu(dev, map, len, DMA_FROM_DEVICE);
/* CPU写完后，设备读之*/
dma_sync_single_for_device(dev, map, len, DMA_TO_DEVICE);

/* 3. 检查是否启用了总线主控 */
u16 cmd;
pci_read_config_word(pdev, PCI_COMMAND, &cmd);
if (!(cmd & PCI_COMMAND_MASTER)) {
    dev_err(&pdev->dev, "bus master not enabled!\n");
    pci_set_master(pdev);  // 重新启用
}