PCIe 设备驱动开发

/*
 * pci_dev - 表示一个PCI设备
 * 包含设备的所有信息：配置空间、资源、驱动等
 */
struct pci_dev {
    struct list_head bus_list;      /* 总线链表 */
    struct pci_bus *bus;            /* 所属总线 */
    struct pci_bus *subordinate;    /* 桥接设备的下游总线 */
    
    u16 vendor;                     /* 厂商ID */
    u16 device;                     /* 设备ID */
    u16 subsystem_vendor;           /* 子系统厂商ID */
    u16 subsystem_device;           /* 子系统设备ID */
    u8 revision;                    /* 修订版本 */
    u8 hdr_type;                    /* 头部类型 */
    
    struct resource resource[DEVICE_COUNT_RESOURCE]; /* BAR资源 */
    
    u8 irq;                         /* 中断号 */
    struct msix_entry *msix_entries; /* MSI-X条目 */
    
    struct pci_driver *driver;      /* 绑定的驱动 */
    void *driver_data;              /* 驱动私有数据 */
};

/*
 * pci_driver - PCI驱动结构
 * 定义驱动标识、探测/移除回调等
 */
struct pci_driver {
    struct list_head node;
    const char *name;
    const struct pci_device_id *id_table;
    
    int (*probe)(struct pci_dev *dev, const struct pci_device_id *id);
    void (*remove)(struct pci_dev *dev);
    int (*suspend)(struct pci_dev *dev, pm_message_t state);
    int (*resume)(struct pci_dev *dev);
    void (*shutdown)(struct pci_dev *dev);
    
    struct device_driver driver;
    const struct pci_error_handlers *err_handler;
};

/*
 * 定义设备ID表 - 驱动匹配规则
 */
static const struct pci_device_id my_pci_ids[] = {
    /* vendor, device, subvendor, subdevice, class, class_mask, driver_data */
    { PCI_DEVICE(0x1234, 0x5678) },  /* 匹配厂商1234, 设备5678 */
    { PCI_DEVICE_CLASS(PCI_CLASS_STORAGE_NVME, 0xffffff) }, /* 匹配NVMe类 */
    { 0, }
};
MODULE_DEVICE_TABLE(pci, my_pci_ids);

/*
 * 驱动结构定义
 */
static struct pci_driver my_pci_driver = {
    .name = "my_pci_driver",
    .id_table = my_pci_ids,
    .probe = my_probe,
    .remove = my_remove,
};

/*
 * 模块注册
 */
module_pci_driver(my_pci_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("PCIe Device Driver Example");

static int my_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
    int ret;
    void __iomem *mmio_base;
    struct my_device *dev;
    
    /* 1. 启用PCI设备 */
    ret = pci_enable_device(pdev);
    if (ret) {
        dev_err(&pdev->dev, "无法启用设备\n");
        return ret;
    }
    
    /* 2. 请求MMIO区域 (BAR0) */
    ret = pci_request_region(pdev, 0, "my_driver");
    if (ret) {
        dev_err(&pdev->dev, "无法请求BAR0区域\n");
        goto err_disable;
    }
    
    /* 3. 映射MMIO到内核虚拟地址空间 */
    mmio_base = pci_iomap(pdev, 0, 0);
    if (!mmio_base) {
        dev_err(&pdev->dev, "无法映射MMIO\n");
        ret = -ENOMEM;
        goto err_region;
    }
    
    /* 4. 设置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\n");
            goto err_iomap;
        }
    }
    
    /* 5. 启用总线主控 (DMA) */
    pci_set_master(pdev);
    
    /* 6. 分配设备私有结构 */
    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if (!dev) {
        ret = -ENOMEM;
        goto err_iomap;
    }
    
    dev->pdev = pdev;
    dev->mmio_base = mmio_base;
    pci_set_drvdata(pdev, dev);
    
    /* 7. 初始化设备硬件 */
    my_hw_init(dev);
    
    /* 8. 分配中断向量 (优先使用MSI/MSI-X) */
    ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
    if (ret < 0) {
        dev_err(&pdev->dev, "无法分配中断向量: %d\n", ret);
        goto err_free;
    }
    
    /* 9. 注册中断 */
    ret = request_irq(pci_irq_vector(pdev, 0), my_interrupt, IRQF_SHARED,
                      "my_device", dev);
    if (ret) {
        dev_err(&pdev->dev, "无法注册中断\n");
        goto err_irq_vectors;
    }
    
    dev_info(&pdev->dev, "设备初始化成功\n");
    return 0;

err_irq_vectors:
    pci_free_irq_vectors(pdev);
err_free:
    kfree(dev);
err_iomap:
    pci_iounmap(pdev, mmio_base);
err_region:
    pci_release_region(pdev, 0);
err_disable:
    pci_disable_device(pdev);
    return ret;
}

static void my_remove(struct pci_dev *pdev)
{
    struct my_device *dev = pci_get_drvdata(pdev);
    
    if (!dev)
        return;
    
    /* 禁用中断 */
    free_irq(pci_irq_vector(pdev, 0), dev);
    
    /* 释放中断向量 */
    pci_free_irq_vectors(pdev);
    
    /* 停止设备 */
    my_hw_stop(dev);
    
    /* 清理资源 */
    pci_iounmap(pdev, dev->mmio_base);
    pci_release_region(pdev, 0);
    pci_disable_device(pdev);
    
    kfree(dev);
    pci_set_drvdata(pdev, NULL);
}

/*
 * MSI-X中断实现
 */

#define NUM_MSIX_VECTORS 16

struct msix_entry msix_entries[NUM_MSIX_VECTORS];

static irqreturn_t my_msix_handler(int irq, void *data)
{
    struct my_queue *q = data;
    u32 status;
    
    /* 读取中断状态 */
    status = readl(q->mmio + QUEUE_INT_STATUS);
    writel(status, q->mmio + QUEUE_INT_STATUS); /* 清除中断 */
    
    /* 处理完成队列 */
    my_process_completions(q);
    
    return IRQ_HANDLED;
}

static int setup_msix(struct pci_dev *pdev, struct my_device *dev)
{
    int ret, i;
    
    /* 启用MSI-X */
    ret = pci_alloc_irq_vectors(pdev, NUM_MSIX_VECTORS, NUM_MSIX_VECTORS,
                                PCI_IRQ_MSIX);
    if (ret < 0) {
        dev_err(&pdev->dev, "无法分配MSI-X向量: %d\n", ret);
        return ret;
    }
    
    /* 为每个向量注册中断处理函数 */
    for (i = 0; i < NUM_MSIX_VECTORS; i++) {
        int vector = pci_irq_vector(pdev, i);
        
        ret = request_irq(vector, my_msix_handler, 0,
                          "my_device", &dev->queues[i]);
        if (ret) {
            dev_err(&pdev->dev, "无法请求IRQ %d: %d\n", vector, ret);
            goto err_free_irqs;
        }
        
        dev->queues[i].vector = vector;
    }
    
    return 0;

err_free_irqs:
    while (--i >= 0) {
        free_irq(dev->queues[i].vector, &dev->queues[i]);
    }
    pci_free_irq_vectors(pdev);
    return ret;
}

/* MSI 分配路径（简化） */
pci_alloc_irq_vectors(dev, min, max, PCI_IRQ_MSIX)
  └─ pci_setup_msi_context() → msi_domain_alloc_irqs()
       └─ msi_domain_alloc_irqs_all()           /* irq_domain 分层分配 Linux IRQ */
            └─ __msi_domain_alloc_irqs()
                 ├─ irq_domain_alloc_irqs_parent()  /* 向上递归到中断控制器域 */
                 └─ .compose_msi_msg()             /* 由中断控制器填 Address/Data：
                                                      x86 = Local APIC 重定向区 + vector，
                                                      GICv3 = ITS 队列地址 + DeviceID/EventID */
  └─ msi_domain_activate()
       └─ .msi_write_msg() → pci_write_msi_msg()
            └─ __pci_write_msi_msg()           /* 把 Address/Data 写进设备的
                                                  MSI-X Table 表项（或 MSI Cap 寄存器） */

/*
 * GPU驱动典型功能模块
 */

/* 1. 设备初始化 */
static int gpu_init(struct pci_dev *pdev, struct gpu_device *gpu)
{
    /* 启用设备 */
    pci_set_master(pdev);
    
    /* 请求MMIO区域 */
    gpu->mmio = pci_iomap(pdev, 0, 0);  /* BAR0: 寄存器 */
    gpu->fb = pci_iomap(pdev, 2, 0);    /* BAR2: 显存映射 */
    
    /* 初始化命令队列/工作队列 */
    gpu_init_cmd_queue(gpu);
    
    /* 初始化内存管理 */
    gpu_init_memory_manager(gpu);
    
    return 0;
}

/* 2. 中断处理 - 上下文切换、命令完成 */
static irqreturn_t gpu_irq_handler(int irq, void *data)
{
    struct gpu_device *gpu = data;
    u32 intr_status;
    
    intr_status = readl(gpu->mmio + GPU_INTR_STATUS);
    
    if (intr_status & INTR_CMD_COMPLETE)
        handle_cmd_completion(gpu);
    
    if (intr_status & INTR_CTX_SWITCH)
        handle_context_switch(gpu);
    
    if (intr_status & INTR_ERROR)
        handle_gpu_error(gpu);
    
    writel(intr_status, gpu->mmio + GPU_INTR_STATUS);  /* 清除中断 */
    return IRQ_HANDLED;
}

/* 3. 内存管理 - 显存分配 */
struct gpu_buffer *gpu_alloc_buffer(struct gpu_device *gpu, size_t size)
{
    struct gpu_buffer *buf;
    
    /* 分配GPU内存 */
    buf->gpu_addr = gpu_mm_alloc(gpu->mm, size);
    
    /* 可选：映射到用户空间 */
    buf->cpu_addr = dma_alloc_coherent(&gpu->pdev->dev, size,
                                       &buf->dma_addr, GFP_KERNEL);
    
    return buf;
}

/* 4. 命令提交 */
static int gpu_submit_command(struct gpu_device *gpu, 
                               struct gpu_command *cmd)
{
    /* 将命令写入命令缓冲区 */
    gpu_write_cmd_buffer(gpu, cmd);
    
    /* 通知GPU处理命令 */
    writel(CMD_SUBMIT, gpu->mmio + GPU_CMD_DOORBELL);
    
    return 0;
}

# 查看GPU设备
lspci -nn | grep -i nvidia

# 查看GPU详细信息
lspci -vvv -s 01:00.0

# 查看GPU资源
cat /sys/bus/pci/devices/0000:01:00.0/resource

# 查看GPU内存映射区域
cat /proc/iomem | grep -i nvidia

# 查看GPU中断
cat /proc/interrupts | grep -i nvidia

# 使用nvidia-smi查看GPU状态
nvidia-smi -q

# 查看GPUDirect支持
nvidia-smi -q | grep -i peer