1. PCI总线基础与Linux驱动概述

PCI总线作为计算机系统中的关键组成部分，承担着连接外部设备与主机的重要任务。在Linux系统中，PCI设备驱动的开发是嵌入式开发和服务器维护中的常见需求。无论是刚入门的新手还是有一定经验的开发者，理解PCI驱动的工作原理和实现方法都至关重要。

PCI总线最初是为了解决外部设备与主机之间高速数据传输而设计的。它采用并行传输方式，支持32位或64位数据宽度，工作频率可达33MHz或66MHz，最大吞吐率达到266MB/s。随着技术的发展，PCI Express（PCIe）逐渐成为主流，它采用串行传输模式，支持更高的传输速率和更多的设备连接。PCIe每个通道的传输速率可达250MB/s，双向总传输速率甚至能达到8GB/s，远超传统的PCI总线。

在Linux系统中，PCI设备驱动开发涉及多个核心概念和数据结构。首先，我们需要了解PCI总线的基本特点：它具有隐含的中央仲裁系统，能够与处理器和存储器子系统完全并行操作，支持多总线主控能力，并提供地址和数据的奇偶校验。这些特性使得PCI总线在高性能计算和实时数据处理中表现出色。

开发PCI设备驱动时，我们主要关注以下几个数据结构：pci_host_bridge用于连接CPU和PCI系统，pci_bus描述PCI总线，pci_ops包含PCI读写操作函数，pci_slot描述物理插槽，pci_dev表示PCI设备，pci_driver表示PCI驱动程序。这些数据结构之间的关系构成了PCI驱动框架的基础。

在实际开发中，PCI设备驱动通常分为两部分：总线驱动和设备驱动。总线驱动负责设备的识别和资源的分配，而设备驱动则实现设备的具体功能。这种分离的设计使得驱动开发更加模块化和灵活。

2. PCI驱动开发环境搭建与依赖安装

开始PCI设备驱动开发之前，我们需要搭建合适的开发环境。Linux内核提供了完整的PCI驱动框架，但为了顺利进行开发，我们还需要安装一些必要的工具和依赖库。

首先，确保你的系统已经安装了Linux内核头文件。在基于Debian的系统上，可以使用以下命令安装：

sudo apt-get install linux-headers-$(uname -r)

对于基于Red Hat的系统，则使用：

sudo yum install kernel-devel

接下来，我们需要安装PCI工具包，它提供了用于查看和管理PCI设备的实用程序：

sudo apt-get install pciutils  # Debian/Ubuntu
sudo yum install pciutils      # Red Hat/CentOS

此外，为了编译内核模块，我们还需要安装构建工具链：

sudo apt-get install build-essential  # Debian/Ubuntu
sudo yum groupinstall "Development Tools"  # Red Hat/CentOS

在实际开发中，我建议使用一个专门的内核源码树进行开发。虽然可以使用系统自带的头文件，但拥有完整的内核源码可以更方便地查阅内核API和调试问题。你可以从kernel.org下载与你系统内核版本匹配的源码，或者直接使用发行版提供的内核源码包。

为了验证开发环境是否配置正确，我们可以编写一个简单的"Hello World"内核模块进行测试。创建一个名为hello.c的文件，内容如下：

#include <linux/module.h>
#include <linux/init.h>

static int __init hello_init(void)
{
    printk(KERN_INFO "Hello, PCI world!\n");
    return 0;
}

static void __exit hello_exit(void)
{
    printk(KERN_INFO "Goodbye, PCI world!\n");
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

编写对应的Makefile：

obj-m += hello.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

编译并加载模块：

make
sudo insmod hello.ko
dmesg | tail -1  # 应该看到Hello消息
sudo rmmod hello
dmesg | tail -1  # 应该看到Goodbye消息

如果一切正常，说明你的开发环境已经配置正确。在实际的PCI驱动开发中，我们还需要关注内核的配置选项，确保相关的PCI支持已经启用。可以通过检查/boot/config-$(uname -r)文件或使用zcat /proc/config.gz来查看当前内核的配置选项。

3. PCI设备探测与初始化实现

PCI设备驱动的核心是设备探测和初始化过程。当系统发现一个PCI设备时，它会遍历所有已注册的PCI驱动程序，检查设备的厂商ID和设备ID是否与驱动程序支持的设备匹配。如果匹配成功，就会调用驱动程序的probe函数进行设备初始化。

让我们详细分析一下probe函数的实现。首先，我们需要定义驱动程序支持的设备ID表：

static const struct pci_device_id my_driver_ids[] = {
    { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x100f) },
    { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82599_SFP) },
    { 0, }
};
MODULE_DEVICE_TABLE(pci, my_driver_ids);

在probe函数中，我们首先需要启用PCI设备：

static int my_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
    int retval;
    struct my_device *priv;
    
    // 启用PCI设备
    retval = pci_enable_device(dev);
    if (retval) {
        dev_err(&dev->dev, "Failed to enable PCI device\n");
        return retval;
    }
    
    // 分配设备私有数据结构
    priv = kzalloc(sizeof(*priv), GFP_KERNEL);
    if (!priv) {
        retval = -ENOMEM;
        goto err_disable;
    }
    
    // 获取设备资源信息
    priv->io_start = pci_resource_start(dev, 0);
    priv->io_len = pci_resource_len(dev, 0);
    priv->irq = dev->irq;
    
    // 请求I/O区域
    retval = pci_request_regions(dev, "my_driver");
    if (retval) {
        dev_err(&dev->dev, "Failed to request regions\n");
        goto err_free;
    }
    
    // 映射I/O内存
    priv->ioaddr = pci_iomap(dev, 0, priv->io_len);
    if (!priv->ioaddr) {
        retval = -ENOMEM;
        goto err_release;
    }
    
    // 设置DMA掩码
    retval = pci_set_dma_mask(dev, DMA_BIT_MASK(64));
    if (retval) {
        retval = pci_set_dma_mask(dev, DMA_BIT_MASK(32));
        if (retval) {
            dev_err(&dev->dev, "No suitable DMA mask\n");
            goto err_unmap;
        }
    }
    
    // 注册中断处理程序
    retval = request_irq(priv->irq, my_interrupt_handler, 
                        IRQF_SHARED, "my_driver", priv);
    if (retval) {
        dev_err(&dev->dev, "Failed to request IRQ\n");
        goto err_unmap;
    }
    
    // 初始化设备硬件
    retval = my_hw_init(priv);
    if (retval) {
        dev_err(&dev->dev, "Hardware initialization failed\n");
        goto err_irq;
    }
    
    // 保存私有数据
    pci_set_drvdata(dev, priv);
    
    dev_info(&dev->dev, "Device initialized successfully\n");
    return 0;

err_irq:
    free_irq(priv->irq, priv);
err_unmap:
    pci_iounmap(dev, priv->ioaddr);
err_release:
    pci_release_regions(dev);
err_free:
    kfree(priv);
err_disable:
    pci_disable_device(dev);
    return retval;
}

这个probe函数展示了典型的PCI设备初始化流程。在实际项目中，你可能需要根据具体设备的特点调整这个流程。例如，某些设备可能需要多个BAR（Base Address Register）区域，或者需要特殊的中断处理方式。

设备初始化完成后，驱动程序就可以开始处理设备的I/O操作了。需要注意的是，probe函数应该尽可能快速完成，避免长时间的操作阻塞其他设备的初始化。

4. 中断处理与DMA操作详解

中断处理和DMA操作是PCI设备驱动中的两个关键部分。正确处理中断可以确保设备能够及时响应事件，而正确使用DMA可以提高数据传输效率。

4.1 中断处理实现

PCI设备通常使用MSI（Message Signaled Interrupts）或传统的中断引脚来产生中断。现代设备更推荐使用MSI，因为它可以减少中断延迟和避免中断共享带来的问题。

注册中断处理程序的基本方法如下：

static irqreturn_t my_interrupt_handler(int irq, void *dev_id)
{
    struct my_device *priv = dev_id;
    u32 status;
    
    // 读取中断状态寄存器
    status = ioread32(priv->ioaddr + STATUS_REG);
    
    // 检查是否有待处理的中断
    if (!(status & INT_PENDING)) {
        return IRQ_NONE;
    }
    
    // 处理不同类型的中断
    if (status & DATA_READY) {
        handle_data_ready(priv);
    }
    
    if (status & TX_COMPLETE) {
        handle_tx_complete(priv);
    }
    
    if (status & ERROR_CONDITION) {
        handle_error(priv);
    }
    
    // 清除中断状态
    iowrite32(status, priv->ioaddr + STATUS_REG);
    
    return IRQ_HANDLED;
}

对于MSI中断，我们需要在probe函数中启用MSI支持：

int retval = pci_alloc_irq_vectors(dev, 1, 1, PCI_IRQ_MSI | PCI_IRQ_LEGACY);
if (retval < 0) {
    dev_err(&dev->dev, "Failed to allocate IRQ vectors\n");
    return retval;
}

priv->irq = pci_irq_vector(dev, 0);
retval = request_irq(priv->irq, my_interrupt_handler, 0, "my_driver", priv);

4.2 DMA操作实现

DMA（Direct Memory Access）允许设备直接访问系统内存，而不需要CPU的参与。这可以显著提高数据传输效率，特别是在处理大量数据时。

PCI设备驱动中DMA操作的基本步骤：

// 设置DMA掩码
retval = pci_set_dma_mask(dev, DMA_BIT_MASK(64));
if (retval) {
    retval = pci_set_dma_mask(dev, DMA_BIT_MASK(32));
    if (retval) {
        dev_err(&dev->dev, "No suitable DMA mask\n");
        return retval;
    }
}

// 分配DMA缓冲区
struct dma_buf {
    dma_addr_t dma_handle;
    void *cpu_addr;
    size_t size;
};

struct dma_buf *alloc_dma_buffer(struct device *dev, size_t size)
{
    struct dma_buf *buf = kmalloc(sizeof(*buf), GFP_KERNEL);
    if (!buf)
        return NULL;
    
    buf->cpu_addr = dma_alloc_coherent(dev, size, &buf->dma_handle, GFP_KERNEL);
    if (!buf->cpu_addr) {
        kfree(buf);
        return NULL;
    }
    
    buf->size = size;
    return buf;
}

// 启动DMA传输
void start_dma_transfer(struct my_device *priv, struct dma_buf *buf, 
                       size_t size, int direction)
{
    // 设置DMA源/目标地址
    iowrite32(lower_32_bits(buf->dma_handle), 
              priv->ioaddr + DMA_ADDR_LOW_REG);
    iowrite32(upper_32_bits(buf->dma_handle), 
              priv->ioaddr + DMA_ADDR_HIGH_REG);
    
    // 设置传输大小
    iowrite32(size, priv->ioaddr + DMA_SIZE_REG);
    
    // 设置传输方向并启动DMA
    u32 ctrl = ioread32(priv->ioaddr + DMA_CTRL_REG);
    ctrl |= DMA_START | direction;
    iowrite32(ctrl, priv->ioaddr + DMA_CTRL_REG);
}

在实际使用中，我们需要根据设备的具体要求来调整DMA操作。有些设备可能需要特殊的内存对齐要求，或者支持分散/聚集（scatter-gather）DMA操作。

5. 资源管理与错误处理策略

良好的资源管理和错误处理是编写稳定可靠的PCI设备驱动的关键。Linux内核提供了丰富的API来帮助开发者管理资源和处理错误。

5.1 资源管理

PCI设备驱动需要管理多种类型的资源，包括I/O内存、I/O端口、中断和DMA缓冲区。正确的资源管理可以避免资源泄漏和冲突。

资源管理的最佳实践：

static int my_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
    struct my_device *priv;
    int retval;
    
    // 启用设备
    retval = pci_enable_device(dev);
    if (retval)
        return retval;
    
    // 尝试启用设备唤醒功能
    pci_enable_wake(dev, PCI_D0, true);
    
    // 请求所有区域
    retval = pci_request_selected_regions(dev, 
                 pci_select_bars(dev, IORESOURCE_MEM), "my_driver");
    if (retval)
        goto err_disable;
    
    // 映射所有需要的BAR
    for (int i = 0; i < DEVICE_BAR_COUNT; i++) {
        if (pci_resource_flags(dev, i) & IORESOURCE_MEM) {
            priv->bar[i].addr = pci_iomap(dev, i, 0);
            if (!priv->bar[i].addr) {
                retval = -ENOMEM;
                goto err_unmap;
            }
            priv->bar[i].len = pci_resource_len(dev, i);
        }
    }
    
    // 其他初始化操作...
    return 0;

err_unmap:
    for (int i = 0; i < DEVICE_BAR_COUNT; i++) {
        if (priv->bar[i].addr)
            pci_iounmap(dev, priv->bar[i].addr);
    }
    pci_release_selected_regions(dev, 
        pci_select_bars(dev, IORESOURCE_MEM));
err_disable:
    pci_disable_device(dev);
    return retval;
}

5.2 错误处理

完善的错误处理机制可以确保驱动在遇到问题时能够优雅地降级或恢复。以下是一些错误处理的建议：

1. 超时处理：对于硬件操作，总是设置合理的超时时间：

#define TIMEOUT_MS 1000

int wait_for_ready(struct my_device *priv)
{
    unsigned long timeout = jiffies + msecs_to_jiffies(TIMEOUT_MS);
    
    while (time_before(jiffies, timeout)) {
        if (ioread32(priv->ioaddr + STATUS_REG) & READY_BIT)
            return 0;
        cpu_relax();
    }
    
    return -ETIMEDOUT;
}

2. 错误恢复：实现错误恢复机制，使设备能够从错误状态中恢复：

void my_device_recover(struct my_device *priv)
{
    // 停止所有DMA操作
    iowrite32(0, priv->ioaddr + DMA_CTRL_REG);
    
    // 重置设备
    iowrite32(RESET_BIT, priv->ioaddr + CONTROL_REG);
    msleep(10);
    iowrite32(0, priv->ioaddr + CONTROL_REG);
    
    // 重新初始化硬件
    my_hw_init(priv);
}

3. 状态监控：定期检查设备状态，及时发现和处理问题：

static void monitor_work_handler(struct work_struct *work)
{
    struct my_device *priv = container_of(work, struct my_device, monitor_work);
    
    u32 status = ioread32(priv->ioaddr + STATUS_REG);
    if (status & ERROR_BITS) {
        dev_warn(&priv->pci_dev->dev, "Device error detected: 0x%08x\n", status);
        my_device_recover(priv);
    }
    
    // 重新调度监控工作
    schedule_delayed_work(&priv->monitor_work, MONITOR_INTERVAL);
}

4. 日志记录：使用适当的日志级别记录错误信息：

// 使用dev_err记录严重错误
dev_err(&dev->dev, "Failed to initialize hardware: %d\n", retval);

// 使用dev_warn记录警告信息
dev_warn(&dev->dev, "Unexpected device state: 0x%08x\n", status);

// 使用dev_info记录重要事件
dev_info(&dev->dev, "Device initialized, IRQ: %d\n", priv->irq);

// 使用dev_dbg记录调试信息
dev_dbg(&dev->dev, "Register 0x%02x value: 0x%08x\n", reg, value);

通过实现完善的资源管理和错误处理机制，可以大大提高PCI设备驱动的稳定性和可靠性。在实际开发中，建议使用Linux内核提供的devres（Device Resource Management）API来自动管理资源，这可以简化错误处理代码并减少资源泄漏的可能性。

6. 实际案例：网络设备驱动开发

让我们通过一个实际的网络设备驱动开发案例来综合应用前面讨论的技术。这个例子基于Intel 82599网卡控制器，展示一个简化的PCIe网络设备驱动实现。

首先定义设备的数据结构：

struct my_net_device {
    struct pci_dev *pdev;
    struct net_device *netdev;
    void __iomem *ioaddr;
    dma_addr_t dma_handle;
    void *dma_buf;
    int irq;
    spinlock_t lock;
    struct napi_struct napi;
};

实现基本的初始化和清理函数：

static int my_net_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
    struct my_net_device *priv;
    struct net_device *netdev;
    int retval;

    // 分配网络设备结构
    netdev = alloc_etherdev(sizeof(*priv));
    if (!netdev)
        return -ENOMEM;

    SET_NETDEV_DEV(netdev, &pdev->dev);
    priv = netdev_priv(netdev);
    priv->netdev = netdev;
    priv->pdev = pdev;

    // 启用PCI设备
    retval = pci_enable_device(pdev);
    if (retval)
        goto err_free_netdev;

    // 请求内存区域
    retval = pci_request_regions(pdev, "my_net_driver");
    if (retval)
        goto err_disable;

    // 映射IO内存
    priv->ioaddr = pci_iomap(pdev, 0, 0);
    if (!priv->ioaddr) {
        retval = -ENOMEM;
        goto err_release;
    }

    // 设置DMA掩码
    retval = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
    if (retval) {
        retval = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
        if (retval)
            goto err_unmap;
    }

    // 分配DMA缓冲区
    priv->dma_buf = dma_alloc_coherent(&pdev->dev, DMA_BUF_SIZE,
                                      &priv->dma_handle, GFP_KERNEL);
    if (!priv->dma_buf) {
        retval = -ENOMEM;
        goto err_unmap;
    }

    // 获取IRQ
    priv->irq = pci_irq_vector(pdev, 0);
    if (priv->irq < 0) {
        retval = priv->irq;
        goto err_dma_free;
    }

    // 初始化自旋锁
    spin_lock_init(&priv->lock);

    // 初始化NAPI
    netif_napi_add(netdev, &priv->napi, my_poll, 64);

    // 设置网络设备操作
    netdev->netdev_ops = &my_netdev_ops;
    netdev->ethtool_ops = &my_ethtool_ops;

    // 注册网络设备
    retval = register_netdev(netdev);
    if (retval)
        goto err_napi;

    pci_set_drvdata(pdev, priv);
    return 0;

err_napi:
    netif_napi_del(&priv->napi);
err_dma_free:
    dma_free_coherent(&pdev->dev, DMA_BUF_SIZE, 
                     priv->dma_buf, priv->dma_handle);
err_unmap:
    pci_iounmap(pdev, priv->ioaddr);
err_release:
    pci_release_regions(pdev);
err_disable:
    pci_disable_device(pdev);
err_free_netdev:
    free_netdev(netdev);
    return retval;
}

实现网络设备操作：

static const struct net_device_ops my_netdev_ops = {
    .ndo_open = my_net_open,
    .ndo_stop = my_net_stop,
    .ndo_start_xmit = my_net_xmit,
    .ndo_set_mac_address = my_net_set_mac,
    .ndo_get_stats64 = my_net_get_stats,
    .ndo_do_ioctl = my_net_ioctl,
    .ndo_change_mtu = my_net_change_mtu,
};

static int my_net_open(struct net_device *netdev)
{
    struct my_net_device *priv = netdev_priv(netdev);
    int retval;

    // 分配发送和接收环缓冲区
    retval = my_alloc_rings(priv);
    if (retval)
        return retval;

    // 初始化硬件
    my_hw_init(priv);

    // 请求IRQ
    retval = request_irq(priv->irq, my_net_interrupt, 
                        IRQF_SHARED, netdev->name, priv);
    if (retval)
        goto err_free_rings;

    // 启用NAPI
    napi_enable(&priv->napi);

    // 启动传输队列
    netif_start_queue(netdev);

    return 0;

err_free_rings:
    my_free_rings(priv);
    return retval;
}

实现中断处理和数据包处理：

static irqreturn_t my_net_interrupt(int irq, void *dev_id)
{
    struct my_net_device *priv = dev_id;
    u32 status;

    // 读取中断状态
    status = ioread32(priv->ioaddr + ISR_REG);

    if (!status)
        return IRQ_NONE;

    // 清除中断状态
    iowrite32(status, priv->ioaddr + ISR_REG);

    // 处理接收中断
    if (status & RX_INT) {
        if (napi_schedule_prep(&priv->napi)) {
            my_disable_rx_irq(priv);
            __napi_schedule(&priv->napi);
        }
    }

    // 处理发送中断
    if (status & TX_INT) {
        my_handle_tx_complete(priv);
    }

    return IRQ_HANDLED;
}

static int my_poll(struct napi_struct *napi, int budget)
{
    struct my_net_device *priv = container_of(napi, 
                                struct my_net_device, napi);
    int work_done = 0;

    // 处理接收数据包
    work_done = my_process_rx(priv, budget);

    // 如果处理了所有数据包，退出NAPI
    if (work_done < budget) {
        napi_complete_done(napi, work_done);
        my_enable_rx_irq(priv);
    }

    return work_done;
}

这个案例展示了PCIe网络设备驱动的基本框架。在实际开发中，还需要实现更多的功能，如流量控制、统计信息收集、电源管理等。通过这个例子，我们可以看到PCI设备驱动开发涉及多个方面的知识，包括PCI总线操作、中断处理、DMA操作、网络协议栈等。

7. 调试技巧与性能优化

开发PCI设备驱动时，调试和性能优化是不可避免的环节。掌握正确的调试方法和优化技巧可以大大提高开发效率。

7.1 调试技巧

1. 使用printk进行日志记录：

// 定义调试级别
#define MY_DEBUG 1

#if MY_DEBUG
#define my_debug(fmt, args...) \
    printk(KERN_DEBUG "my_driver: %s: " fmt, __func__, ##args)
#else
#define my_debug(fmt, args...) 
#endif

// 在代码中使用
my_debug("Register 0x%02x value: 0x%08x\n", reg, value);

2. 使用动态调试：Linux内核支持动态调试，可以在运行时启用或禁用调试信息：

#include <linux/dynamic_debug.h>

// 在代码中添加调试点
defyne_dynamic_debug_enabled(debug);
if (debug)
    dev_dbg(&dev->dev, "Debug information\n");

3. 使用proc和sysfs文件系统：创建调试接口来查看设备状态：

// 在/proc中创建调试文件
static int my_proc_show(struct seq_file *m, void *v)
{
    struct my_device *priv = m->private;
    
    seq_printf(m, "Device status:\n");
    seq_printf(m, "  IRQ: %d\n", priv->irq);
    seq_printf(m, "  I/O address: 0x%lx\n", (unsigned long)priv->ioaddr);
    seq_printf(m, "  DMA handle: 0x%llx\n", (u64)priv->dma_handle);
    
    return 0;
}

static int my_proc_open(struct inode *inode, struct file *file)
{
    return single_open(file, my_proc_show, PDE_DATA(inode));
}

static const struct proc_ops my_proc_ops = {
    .proc_open = my_proc_open,
    .proc_read = seq_read,
    .proc_lseek = seq_lseek,
    .proc_release = single_release,
};

// 在probe函数中创建proc文件
proc_create_data("my_debug", 0444, NULL, &my_proc_ops, priv);

7.2 性能优化

1. 使用DMA池：对于小规模的DMA操作，使用DMA池可以提高性能：

#include <linux/dmapool.h>

struct dma_pool *pool;

// 创建DMA池
pool = dma_pool_create("my_pool", &pdev->dev, 
                      POOL_ITEM_SIZE, POOL_ALIGN, 0);

// 从池中分配DMA内存
void *buf = dma_pool_alloc(pool, GFP_KERNEL, &dma_handle);

// 释放DMA内存
dma_pool_free(pool, buf, dma_handle);

// 销毁DMA池
dma_pool_destroy(pool);

2. 优化中断处理：使用NAPI（New API）来处理网络数据包，减少中断开销：

// 初始化NAPI
netif_napi_add(netdev, &priv->napi, my_poll, NAPI_WEIGHT);

// 在中断处理程序中调度NAPI
if (napi_schedule_prep(&priv->napi)) {
    my_disable_irq(priv);
    __napi_schedule(&priv->napi);
}

// NAPI轮询函数
static int my_poll(struct napi_struct *napi, int budget)
{
    struct my_device *priv = container_of(napi, 
                                struct my_device, napi);
    int work_done = 0;
    
    // 处理接收的数据包
    work_done = my_process_rx(priv, budget);
    
    if (work_done < budget) {
        napi_complete_done(napi, work_done);
        my_enable_irq(priv);
    }
    
    return work_done;
}

3. 使用多队列：对于多核系统，使用多队列可以提高并行性：

// 为每个CPU核心创建发送和接收队列
for_each_online_cpu(cpu) {
    struct my_queue *queue = &priv->queues[cpu];
    
    queue->priv = priv;
    queue->cpu = cpu;
    
    // 分配队列特定的资源
    queue->dma_buf = dma_alloc_coherent(&pdev->dev, 
                        QUEUE_SIZE, &queue->dma_handle, GFP_KERNEL);
    
    // 设置队列中断
    queue->irq = pci_irq_vector(pdev, cpu);
    request_irq(queue->irq, my_queue_interrupt, 
                0, "my_driver", queue);
}

4. 内存访问优化：使用适当的内存屏障和缓存优化：

// 写入设备寄存器时使用内存屏障
iowrite32(value, priv->ioaddr + REG_OFFSET);
mmiowb();  // 确保写入顺序

// 读取设备寄存器时使用适当的屏障
value = ioread32(priv->ioaddr + REG_OFFSET);
rmb();  // 确保读取顺序

5. 使用性能分析工具：利用Linux内核的性能分析工具来识别瓶颈：

# 使用perf进行性能分析
perf record -g -e cycles:u ./test_program
perf report

# 使用ftrace进行函数跟踪
echo function > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/tracing_on
# 运行测试
echo 0 > /sys/kernel/debug/tracing/tracing_on
cat /sys/kernel/debug/tracing/trace

通过结合这些调试技巧和性能优化方法，可以开发出高效稳定的PCI设备驱动。在实际项目中，建议定期进行性能测试和代码审查，确保驱动代码的质量和性能。