PCIe网卡驱动实现分析（四）--- i350网卡驱动硬件原理和软件实现_网卡硬件实现

i350网卡驱动硬件原理和软件实现

1、硬件原理

2、驱动软件

2.1 初始化

2.1.1 收发包队列数据结构创建

2.1.2 中断初始化

2.2 数据发送流程

2.3 数据接收流程

一、硬件原理

　　如下图所示，I350网卡是一个pcie设备，通过pcie接口连接到cpu小系统；i350中有4个LAN口，每个LAN口是一个pcie function，每个LAN外接可选择Serdes或者PHY；每个LAN内部有4个发包队列和4个收包队列，i350内部有DMA控制器，软件驱动可在内存分别创建4个发包队列和4个收包队列，通过设置寄存器，可将内存的队列和i350内部的队列建立一一对应关系，两者之间的数据搬移由DMA完成，并且通过设置寄存器，每个队列可绑定一个msix中断，DMA完成数据搬移后，通过对应中断通知cpu该队列的数据搬移完成；

二、驱动软件

　　pcie设备驱动基于linux的设备驱动总线架构，内核在PCIe设备枚举过程中，已经创建i350设备对应的pci_dev，用pci_register_driver(&igb_driver)函数将i350的驱动注册到内核，igb_driver结构体里面填入i350的供应商ID和设备ID，就会和i350的设备结构体pci_dev匹配，从而调用i350驱动的probe函数开始初始化。

2.1 初始化

　　初始化流程中，主要做了如下工作：

　　使能pcie内存访问、设置DMA地址掩码、映射获取BAR0空间的基地址；

　　初始化MAC、PHY等参数；

　　创建收发包队列；

　　中断初始化；

 2.1.1 收发包队列数据结构创建

　　I350内部有4个收包队列和4个发包队列，队列需要管理的内容包括数据包buffer、DMA以及中断；如上图所示，驱动程序维护4个收包队列数据结构igb_q_vector和4个发包队列数据结构igb_q_vector，每个igb_q_vector和i350内部的队列一一对应，igb_q_vector的结构成员包含了数据包buffer、DMA描述符以及中断等信息；

　　发包队列数据结构igb_q_vector：

　　发包队列中维护了256个发包buffer（struct igb_tx_buffer），这256个发包buffer以循环队列的数据结构进行管理，并且每个发包buffer对应一个DMA描述符（union e1000_adv_tx_desc），DMA描述符中保存了发包buffer中数据的DMA总线地址和数据长度；256个DMA描述符也组织成循环队列的结构，并且放在一片连续的物理内存中（使用dma_alloc_coherent接口申请的物理地址连续的内存），将DMA描述符的首地址写到i350的TDBAL和TDBAH寄存器，将256个DMA描述符内存的总长度写到TDLEN寄存器，i350内部有两个指示可用描述符的寄存器TDH和TDT，通过修改这2个寄存器，就可以通知i350有哪些描述符可用，那么i350就会将内存中可用的描述符加载到i350内部。

/*
 * 创建发包队列igb_q_vector，其中队列成员ring里面保存了发包buffer和DMA描述符
 * 分配256个发包buffer
 * 分配256个物理地址连续的DMA描述符
 * 将管理队列的变量清0
 * 将DMA描述符内存的信息写到对应寄存器告知i350
*/
/* 创建发包队列igb_q_vector，其中队列成员ring里面保存了发包buffer和DMA描述符 */
struct igb_q_vector *q_vector;
struct igb_ring *ring;
size = sizeof(struct igb_q_vector) + (sizeof(struct igb_ring) * ring_count);
q_vector = kzalloc(size, GFP_KERNEL);
/* 分配256个发包buffer */
size = sizeof(struct igb_tx_buffer) * tx_ring->count;
tx_ring->tx_buffer_info = vmalloc(size);
/* 分配256个物理地址连续no cache的DMA描述符 */
tx_ring->size = tx_ring->count * sizeof(union e1000_adv_tx_desc);
tx_ring->size = ALIGN(tx_ring->size, 4096);
tx_ring->desc = dma_alloc_coherent(dev, tx_ring->size, &tx_ring->dma, GFP_KERNEL);
/* 将管理队列的变量清0 */
tx_ring->next_to_use = 0;
tx_ring->next_to_clean = 0;
/* 将DMA描述符内存的信息写到对应寄存器告知i350 */
wr32(E1000_TDLEN(reg_idx), ring->count * sizeof(union e1000_adv_tx_desc));
wr32(E1000_TDBAL(reg_idx), tdba & 0x00000000ffffffffULL);
wr32(E1000_TDBAH(reg_idx), tdba >> 32);
ring->tail = adapter->io_addr + E1000_TDT(reg_idx);
wr32(E1000_TDH(reg_idx), 0);
writel(0, ring->tail);

　　收包队列数据结构igb_q_vector：

　　和发包队列一样，收包队列中也中维护了256个收包buffer（struct igb_rx_buffer），这256个收包buffer以循环队列的数据结构进行管理，并且每个收包buffer对应一个DMA描述符（union e1000_adv_rx_desc），DMA描述符中保存了收包buffer中数据的DMA总线地址和数据长度；256个DMA描述符也组织成循环队列的结构，并且放在一片连续的物理内存中（使用dma_alloc_coherent接口申请的物理地址连续的内存），将DMA描述符的首地址写到i350的RDBAL和RDBAH寄存器，将256个DMA描述符内存的总长度写到RDLEN寄存器，i350内部有两个指示可用描述符的寄存器RDH和RDT，通过修改这2个寄存器，就可以通知i350有哪些描述符可用，那么i350就会将内存中可用的描述符加载到i350内部。

　　并且，对于每个收包buffer，需要预先分配数据包内存，并且把数据包内存填充到DMA描述符，然后通过RDT寄存器通知i350将收包描述符加载到i350内部，这样数据包到达i350内部收包队列后，i350就可以使用DMA描述符将数据包拷贝到内存对应队列的收包buffer中。

/*
 * 创建收包队列igb_q_vector，其中队列成员ring里面保存了收包buffer和DMA描述符
 * 分配256个收包buffer
 * 分配256个物理地址连续no cache的DMA描述符
 * 将管理队列的变量清0
 * 将DMA描述符内存的信息写到对应寄存器告知i350
 * 给每个收包buffer的数据包缓存分配page，并且填充DMA描述符
 * 更新循环队列管理变量，将next_to_use的值写入RDT寄存器，告知i350加载新的收包DMA描述符
*/
/* 创建收包队列igb_q_vector，其中队列成员ring里面保存了收包buffer和DMA描述符 */
struct igb_q_vector *q_vector;
struct igb_ring *ring;
size = sizeof(struct igb_q_vector) + (sizeof(struct igb_ring) * ring_count);
q_vector = kzalloc(size, GFP_KERNEL);
/* 分配256个收包buffer */
size = sizeof(struct igb_rx_buffer) * rx_ring->count;
rx_ring->rx_buffer_info = vmalloc(size);
/* 分配256个物理地址连续no cache的DMA描述符 */
rx_ring->size = rx_ring->count * sizeof(union e1000_adv_rx_desc);
rx_ring->size = ALIGN(rx_ring->size, 4096);
rx_ring->desc = dma_alloc_coherent(dev, rx_ring->size, &rx_ring->dma, GFP_KERNEL);
/* 将管理队列的变量清0 */
rx_ring->next_to_alloc = 0;
rx_ring->next_to_clean = 0;
rx_ring->next_to_use = 0;
/* 将DMA描述符内存的信息写到对应寄存器告知i350 */
wr32(E1000_RDBAL(reg_idx), rdba & 0x00000000ffffffffULL);
wr32(E1000_RDBAH(reg_idx), rdba >> 32);
wr32(E1000_RDLEN(reg_idx), ring->count * sizeof(union e1000_adv_rx_desc));
ring->tail = adapter->io_addr + E1000_RDT(reg_idx);
wr32(E1000_RDH(reg_idx), 0);
writel(0, ring->tail);
/* 给每个收包buffer的数据包缓存分配page，并且填充DMA描述符 */
igb_alloc_mapped_page(struct igb_ring *rx_ring, struct igb_rx_buffer *bi)
    struct page *page = bi->page;
    dma_addr_t dma;
    page = dev_alloc_pages(igb_rx_pg_order(rx_ring));
    dma = dma_map_page_attrs(rx_ring->dev, page, 0, igb_rx_pg_size(rx_ring), DMA_FROM_DEVICE, IGB_RX_DMA_ATTR);
    bi->dma = dma;
    bi->page = page;
dma_sync_single_range_for_device(rx_ring->dev, bi->dma, bi->page_offset, bufsz, DMA_FROM_DEVICE);
rx_desc->read.pkt_addr = cpu_to_le64(bi->dma + bi->page_offset);
/* 更新循环队列管理变量，将next_to_use的值写入RDT寄存器，告知i350加载新的收包DMA描述符 */
i += rx_ring->count;
rx_ring->next_to_use = i;
rx_ring->next_to_alloc = i;
wmb();
writel(i, rx_ring->tail);

2.1.2 中断初始化

　　I350驱动使用PCIE的MSIX中断，共注册了9个MSIX中断，其中1个用于link状态变化的通知，另外8个是收发包队列绑定的中断，当某个队列用DMA完成数据搬移后，就会上报对应的MSIX中断；并且每个收发包队列还注册一个NAPI软中断处理函数，这个软中断函数用于完成具体收发包中断的任务，MSIX中断是硬中断，在MSIX中断回调函数中仅负责调度对应队列的NAPI处理函数。

　　中断初始化涉及的内容主要包括：

　　调用pci_enable_msix_range函数配置MSI-X capability structure，创建9个MSIX中断； 合理设置中断相关的寄存器，EIMS（Interrupt Mask Set/Read）寄存器：每个bit对应一个MSIX中断，置1时，enable对应中断，EIMC（Interrupt Mask Clear）寄存器：每个bit对应一个MSIX中断，置1时，disable对应中断，EIAM（Interrupt Ack Auto Clear Mask）寄存器：每个bit对应一个MSIX中断，置1，中断产生时会自动将EIMS对应bit清0以屏蔽该中断，EICR（Interrupt Cause Read）寄存器：每个bit对应一个MSIX中断，中断产生时，对应bit置1，EIAC（Interrupt Auto Clear）寄存器：每个bit对应一个MSIX中断，置1时，不使用EICR寄存器，也就是中断产生时无法通过读取EICR寄存器获取是哪个中断产生，IMS（Interrupt Mask Set）寄存器：置1时，enable对应中断，这些中断不在EIMS寄存器中，比如bit2（link status change中断）、bit28（NIC DMA out of sync）、bit30（Device Reset Asserted），IMC（Interrupt Mask Clear）寄存器：置1时，disable对应中断，相对IMS寄存器，IAM（Interrupt Acknowledge Auto Mask）寄存器：置1，中断产生时会自动IAM寄存器的值拷贝到IMC以屏蔽中断，功能与EIAM寄存器类似；

　　对于收发包队列中断，由于每个中断都用irq_reqiest注册了一个回调函数，不需要EICR寄存器，因此，初始化时，将EIMS、EIAM、EIAC相应中断bit都置1，这样中断产生时，会自动将EIMS相应bit清0屏蔽中断，然后在完成处理任务后，将EIMS置1重新enable中断，这样省去一次PCIE读TLP的开销；对于eims_other中断，由于该中断绑定了3个事件，中断回调时，需要通过ICR寄存器判断是哪个事件产生中断，因此，初始化时，将IMC和IAM清0，IMS对应bit置1，这样，中断产生时，通过读ICR寄存器判断是哪个事件产生中断；

　　通过设置E1000_IVAR_MISC寄存器，将eims_other绑定到msix vector，那么事件发生后，就会触发对应msix中断；

　　通过设置E1000_IVAR0寄存器，将各收发包队列绑定到对应的msix vector，那么收发包队列进行数据包搬移后，就会触发对应的msix中断；

　　给每个收发包队列注册一个NAPI软中断回调函数；

/*
 * 配置MSI-X capability structure，创建9个MSIX中断
 * 每个队列注册一个NAPI回调函数
 * 合理设置EIAM、EIMC、EIAC、IAM、IMC以disable中断
 * 使用request_irq函数注册9个MSIX中断的回调函数
 * 将msix_other、收发包队列和msix vector绑定起来
 * 使能NAPI软中断、读清pending中断E1000_ICR
 * 合理设置EIAM、EIMC、EIAC、IAM、IMC以enable中断
*/
/* 配置MSI-X capability structure，创建9个MSIX中断 */
for (i = 0; i < numvecs; i++)
    adapter->msix_entries[i].entry = i;
pci_enable_msix_range(adapter->pdev, adapter->msix_entries, numvecs, numvecs);
/* 每个队列注册一个NAPI回调函数 */
netif_napi_add(adapter->netdev, &q_vector->napi, igb_poll, 64);
/* 使用irq_request函数注册回调函数前，先清理屏蔽已经产生的中断 */
igb_irq_disable
    /*
     * 将EIAM（Interrupt Ack Auto Clear Mask）寄存器bit[0:8]清0，该寄存器置1，中断上报后，会将EIMS对应的bit清0
     * 将EIMC（Interrupt Mask Clear）寄存器bit[0:8]写1，失能9个MSIX中断  ---  对应enable中断的寄存器是EIMS
     * 将EIAC（Interrupt Auto Clear）寄存器bit[0:8]清0  --- 该寄存器置1，EICR无法读清，通过读ICR，可以清除EICR对应bit
     * 将IAM（Interrupt Acknowledge Auto Mask）寄存器写0，如果该寄存器置1，那么中断产生时，会自动将IAM寄存器的值拷贝到IMC以屏蔽中断
     * 将IMC（Interrupt Mask Clear）寄存器写1，屏蔽所有类型的中断，相对IMS寄存器
    */
    u32 regval = rd32(E1000_EIAM);
    wr32(E1000_EIAM, regval & ~adapter->eims_enable_mask);
    wr32(E1000_EIMC, adapter->eims_enable_mask);
    regval = rd32(E1000_EIAC);
    wr32(E1000_EIAC, regval & ~adapter->eims_enable_mask);
    wr32(E1000_IAM, 0);
    wr32(E1000_IMC, ~0);
    /* 等待所有pending的中断上报完成 */
    synchronize_irq(adapter->msix_entries[i].vector)
        /* vector就是虚拟中断号irq */
        struct irq_desc *desc = irq_to_desc(irq);
        __synchronize_hardirq(desc);
        wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
/* 注册eims_other中断 */
request_irq(adapter->msix_entries[vector].vector, igb_msix_other, 0, netdev->name, adapter);
/* 每个收发包队列注册对应的中断 */
for (i = 0; i < adapter->num_q_vectors; i++)
    request_irq(adapter->msix_entries[vector].vector, igb_msix_ring, 0, q_vector->name, q_vector);
/* MSIX硬件级相关配置 */    
/* Turn on MSI-X capability first */
wr32(E1000_GPIE, E1000_GPIE_MSIX_MODE |
             E1000_GPIE_PBA | E1000_GPIE_EIAME | --- EIAME模式，设置EIAM相应bit为1，中断上报时，自动清除EIMS，这样中断上报后就处于屏蔽状态
             E1000_GPIE_NSICR);
/* 将msix_other绑定到msix vector */
adapter->eims_other = BIT(vector);
tmp = (vector++ | E1000_IVAR_VALID) << 8;
wr32(E1000_IVAR_MISC, tmp);
/* 将MSIX中断和收发包队列绑定起来 */
if (rx_queue > IGB_N0_QUEUE)
    igb_write_ivar(hw, msix_vector, rx_queue >> 1, (rx_queue & 0x1) << 4);
if (tx_queue > IGB_N0_QUEUE)
    igb_write_ivar(hw, msix_vector, tx_queue >> 1, ((tx_queue & 0x1) << 4) + 8);
/* 使能NAPI软中断 */
napi_enable(&(adapter->q_vector[i]->napi));
/* Clear any pending interrupts. */
rd32(E1000_ICR); /* --- 中断产生后会将该寄存器对应bit置1，该寄存器是读清属性，这些中断不在EICR寄存器中 */
/* 使能中断 */
igb_irq_enable(adapter);
    /*
     * 将EIAC（Interrupt Auto Clear）寄存器的bit[0:8]置1，该寄存器置1后，EICR寄存器（中断产生，该寄存器对应bit被置1）不可读
     * 将EIAM（Interrupt Ack Auto Clear Mask）寄存器的bit[0:8]置1，和EIMS配合使用，清除已经产生的中断
     * 将EIMS（Interrupt Mask Set/Read）寄存器的bit[0:8]置1，enable中断
     * 将IMS（Interrupt Mask Set）寄存器的bit2（link status change中断）、bit28（NIC DMA out of sync）、bit30（Device Reset Asserted）
    */
    u32 regval = rd32(E1000_EIAC);
    wr32(E1000_EIAC, regval | adapter->eims_enable_mask);
    regval = rd32(E1000_EIAM);
    wr32(E1000_EIAM, regval | adapter->eims_enable_mask);
    wr32(E1000_EIMS, adapter->eims_enable_mask);
    u32 ims = E1000_IMS_LSC | E1000_IMS_DOUTSYNC | E1000_IMS_DRSTA;
    wr32(E1000_IMS, ims);

2.2 数据发送流程

　　数据包发送流程包括2个部分：

　　第一个部分，上层调用发包接口，选择一个发包队列，将数据包放到发包队列的发包buffer中，然后填充该发包buffer对应的DMA描述符，更新TDT寄存器告知i350有新的发包描述符，i350加载新增的发包描述符，内部DMA控制器使用发包描述符的信息将数据包从内存队列搬移到i350内部的发包队列；数据包搬移完成后，将描述符处理结果回写到内存对应的发包DMA描述符，然后，产生msix中断通知cpu；

　　第二个部分，cpu收到msix中断后，做2个处理，一个是重新设置下一次中断上报的时间间隔；另一个是调用NAPI处理机制，在NAPI软中断中对发包队列进行清理；

/*
 * 数据包发送流程
 * 第一部分
 * 发包接口ndo_start_xmit，调用发包接口前使用netif_tx_lock_bh(netdev)关软中断、加锁确保发包流程在所有cpu串行
 * 指定发包队列，内存中创建了4个发包队列，为了负载均衡，每次发包时可以选择当前的cpu作为发包队列
 * 发包前需要计算发包buffer的数量，如果数量不够，则不进行发包
 * 填充发包描述符，发送一个数据包，至少要填充4个描述符：contex描述符、skb head描述符、数据信息描述符、RS和EOP描述符
 * 将next_to_use更新为下一次发包使用的位置，并且将next_to_use写入TDT寄存器，通知i350加载上述填充的描述符
*/
1、发包接口ndo_start_xmit
上层调用发包接口前使用netif_tx_lock_bh(netdev)接口关闭当前cpu的软中断，以及占用netdev的自旋锁，这样保证了发包流程在所有cpu的串行
netif_tx_lock_bh(netdev);
netdev->netdev_ops->ndo_start_xmit(skb, netdev);
netif_tx_unlock_bh(netdev);
2、指定发包队列
内存中创建了4个发包队列，为了负载均衡，每次发包时可以选择当前的cpu作为发包队列
ndo_start_xmit
    /* 该函数指定发包队列 */
    igb_tx_queue_mapping(adapter, skb)
        unsigned int r_idx = skb->queue_mapping;
        return adapter->tx_ring[r_idx];
    igb_xmit_frame_ring(skb, igb_tx_queue_mapping(adapter, skb))
3、发包前需要计算发包buffer的数量，如果数量不够，则不进行发包
/* need: 1 descriptor per page * PAGE_SIZE/IGB_MAX_DATA_PER_TXD,
 *       + 1 desc for skb_headlen/IGB_MAX_DATA_PER_TXD,
 *       + 2 desc gap to keep tail from touching head,
 *       + 1 desc for context descriptor,
 * otherwise try next time
 */
每发一个包，都要使用多个发包描述符，分别填充skb head、context以及数据片，并且为了和循环队列head保持距离，发包后至少剩余2个描述符，
因此，发包前按照上述需要计算是否有足够的描述符，如果描述符不够，则不进行发包
/* skb head使用的描述符数量 */
u16 count = TXD_USE_COUNT(skb_headlen(skb));
/* 数据部分使用的描述符数量 */
for (f = 0; f < skb_shinfo(skb)->nr_frags; f++)
    count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size);
/* 加上contex和剩余的2个描述符，总的描述符少于count + 3，则不进行发包 */
if (igb_maybe_stop_tx(tx_ring, count + 3))
    return NETDEV_TX_BUSY;
4、填充发包描述符，包括contex描述符、skb head描述符、数据信息描述符、RS和EOP描述符
第一个发包描述符用于填充数据包的contex信息，包括分片信息、vlan、cksum等
igb_tx_ctxtdesc(tx_ring, vlan_macip_lens, type_tucmd, 0)
    struct e1000_adv_tx_context_desc *context_desc;
    u16 i = tx_ring->next_to_use;
    context_desc = IGB_TX_CTXTDESC(tx_ring, i);
    /* 更新描述符队列next_to_use */
    i++;
    tx_ring->next_to_use = (i < tx_ring->count) ? i : 0;
    /* set bits to identify this as an advanced context descriptor */
    type_tucmd |= E1000_TXD_CMD_DEXT | E1000_ADVTXD_DTYP_CTXT;
    context_desc->vlan_macip_lens    = cpu_to_le32(vlan_macip_lens);
    context_desc->seqnum_seed    = 0;
    context_desc->type_tucmd_mlhl    = cpu_to_le32(type_tucmd);
    context_desc->mss_l4len_idx    = cpu_to_le32(mss_l4len_idx);
第二个发包描述符用于填充skb head信息
union e1000_adv_tx_desc *tx_desc;
dma_addr_t dma;
/* 取出context的下一个描述符 */
u16 i = tx_ring->next_to_use;
tx_desc = IGB_TX_DESC(tx_ring, i);
size = skb_headlen(skb);
/* 将skb head的数据从cache同步到内存，并获取dma总线地址 */
dma = dma_map_single(tx_ring->dev, skb->data, size, DMA_TO_DEVICE);
/* 将skb head的dma总线地址记录在第一个发包buffer中 */
dma_unmap_len_set(tx_buffer, len, size);
dma_unmap_addr_set(tx_buffer, dma, dma);
/* 将skb head的dma总线地址信息填充到发包描述符 */
tx_desc->read.buffer_addr = cpu_to_le64(dma);
tx_desc->read.cmd_type_len = cpu_to_le32(cmd_type ^ size);
/* 递增描述符和发包buffer */
i++;
tx_desc++;
第三个发包描述符用于填充数据信息，如果有多个分片，就填充多个描述符
tx_buffer = &tx_ring->tx_buffer_info[i];
tx_desc->read.olinfo_status = 0;
size = skb_frag_size(frag);
dma = skb_frag_dma_map(tx_ring->dev, frag, 0, size, DMA_TO_DEVICE);
/* dma总线地址信息记录到发包buffer */
dma_unmap_len_set(tx_buffer, len, size);
dma_unmap_addr_set(tx_buffer, dma, dma);
/* dma总线地址信息记录到发包描述符 */
tx_desc->read.buffer_addr = cpu_to_le64(dma);
tx_desc->read.cmd_type_len = cpu_to_le32(cmd_type ^ size);
/* 递增描述符和发包buffer */
i++;
tx_desc++;
最后，再使用一个发包描述符用于填充RS和EOP
/* write last descriptor with RS and EOP bits */
cmd_type |= size | IGB_TXD_DCMD;
tx_desc->read.cmd_type_len = cpu_to_le32(cmd_type);
/* 使用内存屏障语句，确保上述代码都操作完内存 */
wmb();
5、将next_to_use更新为下一次发包使用的位置，并且将next_to_use写入TDT寄存器，通知i350加载上述填充的描述符
/* 第一个发包buffer的next_to_watch要保存RS/EOP的描述符 */
first->next_to_watch = tx_desc;
/* 更新next_to_use、写TDT寄存器 */
i++;
tx_ring->next_to_use = i;
if (netif_xmit_stopped(txring_txq(tx_ring)) || !skb->xmit_more)
    writel(i, tx_ring->tail);
    mmiowb();

/*
 * 数据包发送流程
 * 第二部分
 * msix硬中断处理
 * NAPI软中断机制清理发包队列：
 * 每次最多清理64个数据包，
 * 如果清理满64个，说明队列还有数据包待清理，那么退出本次清理，不开启msix硬件中断，等下次软中断回调再继续清理；
 * 如果清理不满64个，说明队列已经清空，那么设置NAPI处理完成标志，并且重新使能msix硬件中断；
*/
1、msix硬中断处理
/* 根据前一个中断，重新设置下一次中断的上报间隔 */
/* Write the ITR value calculated from the previous interrupt. */
igb_write_itr(q_vector);
    writel(itr_val, q_vector->itr_register);
/* 调度NAPI软中断来清理发包队列 */
napi_schedule(&q_vector->napi);
2、NAPI软中断机制清理发包队列
NAPI处理机制是：
    每次最多清理64个数据包，
    如果清理满64个，说明队列还有数据包待清理，那么退出本次清理，不开启msix硬件中断，等下次软中断回调再继续清理；
    如果清理不满64个，说明队列已经清空，那么设置NAPI处理完成标志，并且重新使能msix硬件中断；
clean_complete = igb_clean_tx_irq(q_vector, budget);
    /* 从next_to_clean开始清理 */
    unsigned int i = tx_ring->next_to_clean;
    tx_buffer = &tx_ring->tx_buffer_info[i];
    tx_desc = IGB_TX_DESC(tx_ring, i);
    i -= tx_ring->count;
    由上述可知，每次发包都至少填充4个描述符，并且第一个发包buffer的next_to_watch指向最后一个RS/EOP描述符；
    因此，这里数据包清理时，通过next_to_watch判断此数据包是否能清理；
    /* 判断是否有RS/EOP描述符 */
    if (!eop_desc)
        break;
    /* prevent any other reads prior to eop_desc */
    read_barrier_depends();
    /* i350处理完描述符后，会将处理结果回写到该描述符内存处，这个通过RS/EOP描述符的状态位判断是否处理完成，处理完成才进行清理 */
    /* if DD is not set pending work has not been completed */
    if (!(eop_desc->wb.status & cpu_to_le32(E1000_TXD_STAT_DD)))
        break;
    清理第一个buffer，也就是skb head的描述符
    /* clear next_to_watch to prevent false hangs */
    tx_buffer->next_to_watch = NULL;
    /* free the skb */
    napi_consume_skb(tx_buffer->skb, napi_budget);
    /* DMA unmap */
    /* unmap skb header data */
    dma_unmap_single(tx_ring->dev, dma_unmap_addr(tx_buffer, dma), dma_unmap_len(tx_buffer, len), DMA_TO_DEVICE);
    dma_unmap_len_set(tx_buffer, len, 0);
    清理剩余的buffer，直到eop_desc
    while (tx_desc != eop_desc)
        tx_buffer++;
        tx_desc++;
        i++;
        /* 由上述可以，有一些buffer没有填充数据，直接跳过这些buffer */
        if (dma_unmap_len(tx_buffer, len))
            dma_unmap_page(tx_ring->dev, dma_unmap_addr(tx_buffer, dma), dma_unmap_len(tx_buffer, len), DMA_TO_DEVICE);
            dma_unmap_len_set(tx_buffer, len, 0);
    /* 继续清理下一个数据包，最多处理64个budget */
    /* move us one more past the eop_desc for start of next pkt */
    tx_buffer++;
    tx_desc++;
    i++;
    /* issue prefetch for next Tx descriptor */
    prefetch(tx_desc);
    /* update budget accounting */
    budget--;
    最后，更新next_to_clean到下一个数据包的位置
    i += tx_ring->count;
    tx_ring->next_to_clean = i;
NAPI回调函数退出前，判断clean_complete是否是64个，如果是，则不开启硬件中断，继续polling，否则开启硬中断，退出NAPI软中断
/* 处理64个，直接返回，不开启硬件中断 */
/* If all work not completed, return budget and keep polling */
if (!clean_complete)
    return budget;
/* 没有处理64个，则退出polling模式，开启硬件中断 */
/* If not enough Rx work done, exit the polling mode */
napi_complete_done(napi, work_done);
igb_ring_irq_enable(q_vector);

2.3 数据包接收流程

　　数据包接收流程可以分为2个阶段，第一个阶段是外部数据包到达i350后，i350内部通过hash机制，将数据包放到一个内部收包队列，这个阶段由i350完成；第二个阶段是i350使用收包描述符将数据包搬移到内存收包队列中，然后上报对应的msix中断通知cpu，驱动代码在msix中断中调度NAPI软中断，在NAPI软中断回调中清理收包buffer，并将数据包送给上层协议栈。

/*
 * 数据包接收流程
 * 外部数据包到达i350后，i350内部通过hash机制将数据包放到内部的一个收包队列
 * 数据包接收msix硬件中断处理，设置下一次中断上报间隔，调度NAPI软中断
 * NAPI软中断清理收包buffer，并将数据包上送协议栈
 * NAPI机制处理数据包：处理64个，直接返回继续下一轮polling，不开启硬件中断；没有处理64个，则退出polling模式，开启硬件中断
*/
1、外部数据包到达i350后，i350内部通过hash机制将数据包放到内部的一个收包队列
这个hash机制在初始化时可以通过寄存器设置
/* configure the multiple receive queue control registers */
igb_setup_mrqc(struct igb_adapter *adapter)
    netdev_rss_key_fill(rss_key, sizeof(rss_key));
    for (j = 0; j < 10; j++)
        wr32(E1000_RSSRK(j), rss_key[j]);
    igb_write_rss_indir_tbl(adapter);
    /* Generate RSS hash based on packet types, TCP/UDP
     * port numbers and/or IPv4/v6 src and dst addresses
     */
    mrqc = E1000_MRQC_RSS_FIELD_IPV4 |
           E1000_MRQC_RSS_FIELD_IPV4_TCP |
           E1000_MRQC_RSS_FIELD_IPV6 |
           E1000_MRQC_RSS_FIELD_IPV6_TCP |
           E1000_MRQC_RSS_FIELD_IPV6_TCP_EX;
    wr32(E1000_MRQC, mrqc);
2、数据包接收msix硬件中断处理
igb_msix_ring(int irq, void *data)
    /* 设置下一次中断上报的时间间隔 */
    /* Write the ITR value calculated from the previous interrupt. */
    igb_write_itr(q_vector);
    /* 调度NAPI软中断 */
    napi_schedule(&q_vector->napi);
3、NAPI软中断清理收包buffer，并将数据包上送协议栈
cleaned = igb_clean_rx_irq(q_vector, budget);
    /* 初始状态cleaned_count是0 */
    u16 cleaned_count = igb_desc_unused(rx_ring);
    /* 一次回调，最多清理64个数据包 */
    while (likely(total_packets < budget))
        /* 从next_to_clean开始清理 */
        union e1000_adv_rx_desc *rx_desc;
        struct igb_rx_buffer *rx_buffer;
        rx_desc = IGB_RX_DESC(rx_ring, rx_ring->next_to_clean);
        /* 收包描述符是i350回写的，需要转成cpu字节序 */
        size = le16_to_cpu(rx_desc->wb.upper.length);
        /* 读描述符前，先使用内存屏障保证软件资源操作内存完成 */
        dma_rmb();
        /* 取出next_to_clean对应的收包buffer */
        rx_buffer = igb_get_rx_buffer(rx_ring, size);
        /* 将接收的数据组装成一个skb */
        skb = igb_construct_skb(rx_ring, rx_buffer, rx_desc, size);
        /* dma unmap，该操作会置cache无效，保证cpu取到最新数据 */
        dma_unmap_page_attrs(rx_ring->dev, rx_buffer->dma, igb_rx_pg_size(rx_ring), DMA_FROM_DEVICE, IGB_RX_DMA_ATTR);
        rx_buffer->page = NULL;
        /* 上述完成则清理了一个数据包 */
        cleaned_count++;
        /* 更新next_to_clean */
        u32 ntc = rx_ring->next_to_clean + 1;
        ntc = (ntc < rx_ring->count) ? ntc : 0;
        rx_ring->next_to_clean = ntc;
        /* 如果这个收包buffer只是分片，那么进行下一次循环继续取分片放到skb里面，直到取出完整的数据包 */
        /* fetch next buffer in frame if non-eop */
        if (igb_is_non_eop(rx_ring, rx_desc))
            continue;
        /* 将数据包skb上送协议栈 */
        napi_gro_receive(&q_vector->napi, skb);
        /* 在数据包清理过程中，如果清理了16个，就调用如下函数，将描述符返回给i350 */
        if (cleaned_count >= IGB_RX_BUFFER_WRITE)
            igb_alloc_rx_buffers(rx_ring, cleaned_count);
                /* 从next_to_use开始清理，清理cleaned_count个数据包 */
                u16 i = rx_ring->next_to_use;
                rx_desc = IGB_RX_DESC(rx_ring, i);
                bi = &rx_ring->rx_buffer_info[i];
                i -= rx_ring->count;
                do {
                    /* 如果没有分配page，就分配page */
                    igb_alloc_mapped_page(rx_ring, bi)
                        struct page *page = bi->page;
                        dma_addr_t dma;
                        page = dev_alloc_pages(igb_rx_pg_order(rx_ring));
                        dma = dma_map_page_attrs(rx_ring->dev, page, 0, igb_rx_pg_size(rx_ring), DMA_FROM_DEVICE, IGB_RX_DMA_ATTR);
                    /* 如果分配了page，将缓存交给i350就行 */
                    dma_sync_single_range_for_device(rx_ring->dev, bi->dma, bi->page_offset, bufsz, DMA_FROM_DEVICE);
                    /* 因为收包描述符被i350回写了，这里要重新将dma总线写到描述符 */
                    rx_desc->read.pkt_addr = cpu_to_le64(bi->dma + bi->page_offset);
                    cleaned_count--;
                } while (cleaned_count);
                /* 最后，更新next_to_alloc，并写入RDT寄存器，让i350加载新的收包描述符 */
                rx_ring->next_to_use = i;
                rx_ring->next_to_alloc = i;
                /* 使用内存屏障，保证数据写内存完成 */
                wmb();
                writel(i, rx_ring->tail);
            cleaned_count = 0;
NAPI回调函数退出前，判断clean_complete是否是64个，如果是，则不开启硬件中断，继续polling，否则开启硬中断，退出NAPI软中断
/* 处理64个，直接返回，不开启硬件中断 */
/* If all work not completed, return budget and keep polling */
if (!clean_complete)
    return budget;
/* 没有处理64个，则退出polling模式，开启硬件中断 */
/* If not enough Rx work done, exit the polling mode */
napi_complete_done(napi, work_done);
igb_ring_irq_enable(q_vector);