Question

这可能是一个愚蠢的问题，但到目前为止我还没有得到关于DMA的信息在对内存执行内存DMA时，需要分配DMA缓冲区（例如使用dma_alloc_coherent()），然后对于每次传输，我们需要将缓冲区复制到分配的内存（源缓冲区），然后触发DMA事务。

因此，如果每个交易需要额外的memcpy()，那么它是什么使用DMA的好处？

将源复制到目标的步骤 - 不带DMA ：

从源到目的地的复制缓冲区（memcpy()）

将源复制到目标的步骤 - with DMA ：

将缓冲区（memcpy()）从源缓冲区复制到DMA缓冲区
触发DMA事务（最终将缓冲区复制到目的地缓冲区）

此问题的一个示例是以太网驱动程序，它需要从收到的sk_buf复制到FPGA的物理地址。在这种情况下，它需要首先将sk_buf复制到DMA源缓冲区（来自dma_alloc_coherent()）。

Answer 1

如果可以将dma_map_single()与sk_buf指针一起使用，则不必将其复制到分配有dma_alloc_coherent()的缓冲区中。网络设备驱动程序中有很多这样的例子。

int dma_len = skb->len;
dma_addr_t dma_addr = dma_map_single(dev, skb->data, skb->len, DMA_TO_DEVICE);

// error checking code here
// then send the dma_addr to the drvice
// when it is done, unmap it
dma_unmap_single(dev, dma_addr, dma_len, DMA_TO_DEVICE);

有关详细信息，请参阅DMA Mapping API documentation。

Answer 2

我想我的答案与帖子所有者不再相关，但也许将来会对其他一些程序员有所帮助。

如此处评论之一所述，如果您的FPGA具有DMA控制器（该控制器允许FPGA读取已映射到DMA的存储器），那么您应该能够在没有{{1}的情况下进行DMA。 }操作。

在这里，我将尝试给出一个简短的（尽可能...）示例，说明如何在Rx流中的以太网驱动程序中实现它（但是有多种方法可以实现它，但这仅仅是一个了解基本步骤和概念的一般示例）。请注意，我已经尝试简化它，所以不要尝试对其进行编译（这不是完整的代码-要查看完整的以太网驱动程序，可以尝试开始研究this驱动程序）。

现在，让我们关注这些基本步骤：

初始化Rx缓冲区
Rx帧接收
为下一个DMA事务准备Rx缓冲区
释放Rx缓冲区

初始化接收缓冲区

memcpy()

接收帧接收

static int init_dma_rx_desc_rings(struct net_device *dev, gfp_t flags)
{
    struct my_private *tp = (struct my_private *)dev->priv;

    int ret = -ENOMEM;
    int i;

    tp->dma_buf_sz = BUF_SIZE_16KiB;

    for (i = 0; i < DMA_RX_SIZE; i++) {
        ret = init_rx_buffers(dev, i, flags);
        if (ret)
            goto err_init_rx_buffers;
    }

    return 0;

err_init_rx_buffers:
    for (i = 0; i < DMA_RX_SIZE; i++) {
        ret = free_rx_buffer(dev, i);
        if (ret)
            goto err_init_rx_buffers;
    }

    return ret;
}

static int init_rx_buffers(struct net_device *dev, int i, gfp_t flags)
{
    struct my_private *tp = (struct my_private *)dev->priv;
    struct sk_buff *skb = __netdev_alloc_skb_ip_align(dev, tp->dma_buf_sz, flags);

    if (!skb) {
        printk("Rx init fails; skb is NULL\n");
        return -ENOMEM;
    }

    tp->rx_skbuff[i] = skb;
    tp->rx_skbuff_dma[i] = dma_map_single(tp->device, skb->data,
                                          tp->dma_buf_sz, DMA_FROM_DEVICE);

    if (dma_mapping_error(tp->device, tp->rx_skbuff_dma[i])) {
        printk("DMA mapping error\n");
        dev_kfree_skb_any(skb);
        return -EINVAL;
    }

    return 0;
}

为下一个DMA事务准备Rx缓冲区

/* should be called by the interrupt handler or NAPI poll method*/
static void receive_packets(struct net_device *dev)
{
    struct my_private *tp = (struct my_private *)dev->priv;
    unsigned int count = 0;
    int rx_work_limit = tp->dirty_rx + RX_RING_SIZE - tp->cur_rx;
    unsigned int next_entry = tp->cur_rx;

    while (count < rx_work_limit) {
        int entry = next_entry;

        /* read the status of the incoming frame */
        int status = get_rx_status(tp);

        /* check if managed by the DMA otherwise go ahead */
        if (unlikely(status & dma_own))
            break;

        count++;
        tp->cur_rx = get_rx_entry(tp->cur_rx, DMA_RX_SIZE);
        next_entry = tp->cur_rx;

        /*  If frame length is greater than skb buffer size
            (preallocated during init) then the packet is ignored */
        int frame_len = get_rx_frame_len(tp);   
        if (frame_len > tp->dma_buf_sz) {
            printk("len %d larger than size (%d)\n", frame_len, tp->dma_buf_sz);    
            continue;
        }

        struct sk_buff *skb = tp->rx_skbuff[entry];
        if (unlikely(!skb)) {
            printk("Inconsistent Rx chain\n");
            continue;
        }

        prefetch(skb->data - NET_IP_ALIGN);
        tp->rx_skbuff[entry] = NULL;

        skb_put(skb, frame_len);
        dma_unmap_single(tp->device, tp->rx_skbuff_dma[entry],
                         tp->dma_buf_sz, DMA_FROM_DEVICE);

       /* from this point it is safe to access the data of the rx skb. 
          the DMA transaction is already complete
          and the rx buffer is unmapped from the DMA */

        netif_receive_skb(skb);
    }

    rx_refill(dev);

    return count;
}

释放Rx缓冲区

static inline void rx_refill(struct net_device *dev)
{
    struct my_private *tp = (struct my_private *)dev->priv;
    int dirty = get_num_of_rx_dirty(tp);
    unsigned int entry = tp->dirty_rx;

    while (dirty-- > 0) {
        if (likely(!tp->rx_skbuff[entry])) {
            struct sk_buff *skb;

            skb = netdev_alloc_skb_ip_align(dev, tp->dma_buf_sz);
            if (unlikely(!skb)) {
                printk("fail to alloc skb entry %d\n", entry);
                break;
            }

            rx_q->rx_skbuff[entry] = skb;
            rx_q->rx_skbuff_dma[entry] = dma_map_single(tp->device, skb->data,
                                                        tp->dma_buf_sz, DMA_FROM_DEVICE);       
            if (dma_mapping_error(tp->device, tp->rx_skbuff_dma[entry])) {
                printk("Rx DMA map failed\n");
                dev_kfree_skb(skb);
                break;
            }
        }

        entry = get_rx_entry(entry, DMA_RX_SIZE);
    }

    tp->dirty_rx = entry;
}

DMA事务需要每次都复制到缓冲区吗？

2 个答案: